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...

Functions
template<class Function , class... Args>
std::future< std::invoke_result_t< std::decay_t< Function >, std::decay_t< Args >... > >	jevois::async (Function &&f, Args &&... args)
	Async execution using a thread pool. More...
template<class Function , class... Args>
std::future< std::invoke_result_t< std::decay_t< Function >, std::decay_t< Args >... > >	jevois::async_little (Function &&f, Args &&... args)
	Async execution using a thread pool. More...

Enumeration Type Documentation

BlockingBehavior

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.

Function Documentation

async()

template<class Function , class... Args>

std::future<std::invoke_result_t<std::decay_t<Function>, std::decay_t<Args>...> > jevois::async	(	Function &&	f,
		Args &&...	args
	)

Async execution using a thread pool.

Same function signature and usage as std::async(). Always launches the task in a parallel thread, using a thread pool. Runs the task on big (ARM A73) cores when using big.little CPU architecture of JeVois Pro Platform. Use this function to launch parallel threads of high priority, e.g., machine vision algorithms.

Referenced by jevois::rawimage::byteSwap(), jevois::MovieOutput::MovieOutput(), TutorialEdgeDetectionX4::process(), jevois::dnn::Pipeline::process(), jevois::dnn::Network::ready(), and jevois::rawimage::unpackCvRGBAtoGrayRawImage().

async_little()

template<class Function , class... Args>

std::future<std::invoke_result_t<std::decay_t<Function>, std::decay_t<Args>...> > jevois::async_little	(	Function &&	f,
		Args &&...	args
	)

Async execution using a thread pool.

Same function signature and usage as std::async(). Always launches the task in a parallel thread, using a thread pool. Runs the task on little (ARM A53) cores when using big.little CPU architecture of JeVois Pro Platform, or on the same thread pool as jevois::async() on other architectures. Use this function to run threads that are not very compute intensive, e.g., threads that may sleep most of the time until some condition has become satisfied.

Referenced by jevois::CameraDevice::CameraDevice(), jevois::GUIhelper::drawSystem(), jevois::Engine::Engine(), jevois::Gadget::Gadget(), and jevois::Watchdog::Watchdog().