JeVois-specific types and generic helper classes

These types and classes support the core JeVois implementation. Pay particular attention to the very useful JEVOIS_DEFINE_ENUM_CLASS(name, SEQ) macro to define new enums that can be used in Parameter to allow menu-style parameters.

JEVOIS_DEFINE_ENUM_CLASS(name, SEQ)

Helper macro to define new enum class types. SEQ should be a BOOST_PP_SEQ (see example syntax below). You will get:

• an enum class declared and defined with the name and values supplied
• a static const std::vector of your enum values, with all the values that the enum can take, in name_Values
• a static const std::vector of std::string, with string names of all the values the enum can take, in name_Strings
• operator<< and operator>> for your enum.

You can in particular use name_Values when defining a Parameter definition to list all the valid values, and the streaming operators will allow you to set the Parameter value by string, etc.

For example:

JEVOIS_DEFINE_ENUM_CLASS(myEnum, (One) (Two) (Three));

expands to:

• first, the actual definition of the enum class, with the values you specified in the sequence:

  enum class myEnum { One, Two, Three };

• second, a static const vector that contains all the enum values, listed in the order you specified:

  static std::vector<myEnum> const myEnum_Values { myEnum::One, myEnum::Two, myEnum::Three };

• third, a static const vector of strings that contains all the enum values in string form, listed in the order you specified:

  static std::vector<std::string> const myEnum_Strings { "One", "Two", "Three" };

• finally, two stream operators that allow you to convert between your enum values and string:

  inline std::ostream & operator<<(std::ostream & os, myEnum const & v) {
    std::vector<myEnum>::const_iterator vitr = myEnum_Values.begin(), vend = myEnum_Values.end();
    std::vector<std::string>::const_iterator sitr = myEnum_Strings.begin();
    while (vitr != vend) if (v == *vitr) { os << *sitr; return os; } else { ++vitr; ++sitr; }
    return os;
  }
  
  inline std::istream & operator>>(std::istream & is, myEnum & v) {
    std::string s; is >> s;
    std::vector<myEnum>::const_iterator vitr = myEnum_Values.begin(), vend = myEnum_Values.end();
    std::vector<std::string>::const_iterator sitr = myEnum_Strings.begin();
    while (vitr != vend) if (s == *sitr) { v = *vitr; return is; } else { ++vitr; ++sitr; }
    throw std::range_error("Invalid value [" + s + "] for Enum class myEnum");
  };

Note how the operator>> will throw if the given string does not match the string representation of one of the enum's values.

Classes
class	jevois::BoundedBuffer< T, WhenFull, WhenEmpty >
	Thread-safe synchronized producer/consumer queue. More...
class	jevois::Range< T >
	A generic range class. More...
class	jevois::Semaphore< BB >
	A simple semaphore. More...
class	jevois::Singleton< T >
	A generic singleton class to enforce a single instance of an object. More...
class	jevois::StepRange< T >
	A generic range class with a step. More...

Enumerations
enum	jevois::BlockingBehavior { jevois::BlockingBehavior::Block, jevois::BlockingBehavior::Throw }
	Behavior when attemting an operation that cannot be completed immediately. More...

Enumeration Type Documentation

enum jevois::BlockingBehavior

strong

Behavior when attemting an operation that cannot be completed immediately.

Defines the behavior of Semaphore, BoundedBuffer, etc.

Enumerator
Block	Block until operation can be completed.
Throw	Throw std::runtime_error if operation cannot be completed immediately.

Definition at line 25 of file BlockingBehavior.H.