Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

▼NEBML
CCIdentifier	Base class to work with EBML identifiers
CIReader	EBML processing class
CIReaderCallback	Callback class to use when parsing the EBML stream
CIReaderHelper	Helper to read basic EBML types
CIWriter	EBML formating class
CIWriterCallback	Callback class to use when creating the EBML stream
CIWriterHelper	Helper to write basic EBML types
▼NOpenViBE	Main OpenViBE namespace
►NKernel	Kernel specifications of the OpenViBE platform
CCErrorManager	Error manager kernel default implementation
CIAlgorithmContext	Exectution context for algorithm objects
CIAlgorithmManager	Manager for all kind of plugin algorithms
CIAlgorithmProto	Prototype interface for algorithm
CIAlgorithmProxy	Application interface to an algorithm plugin
CIAttributable
CIBox	Complete OpenViBE box interfaceThis interface can be used in order to fully describe an OpenViBE black box. It describes its identification values, its inputs, its outputs and its settings
CIBoxAlgorithmContext	Specific context to use for box algorithm pluginsThis 'context' is given by the player to an algorithm plugin so it has all the necessary tools to work. This algorithm context mainly consists in getting other contexts which could be defined and used more generically (such as the box interface or a global player interface for example)
CIBoxIO	Main OpenViBE box interface to communicate with the kernelThis context allows the object which uses it to check inputs states, read them, write outputs while being in a dynamic context (used by player)
CIBoxListenerContext	Exectution context for box algorithm descriptors
CIBoxProto	OpenViBE box prototypeThis class is used by a plugin algorithm descriptor to let the OpenViBE platform know what an algorithm box looks like. It declares several things, like it input types, output types and settings
CIComment	A comment class for scenariosThis interface can be used in order to fully describe an OpenViBE comment in order to help the understanding of a given scenario
CIConfigurable	Configurable object interface
CIConfigurationKeywordExpandCallback	Callback used for overriding a keyword in IConfigurationManager
CIConfigurationManager	Manager for all kind of configuration
CIError	Interface for Kernel error implementationIError interface aims at providing information about an error occurring in the framework. One specific concept here is the notion of nested errors. In a call stack, it can be interesting to catch a n-1 level error and enhance it instead of rethrowing it directy unchanged. In this case, we say the level n-1 error is nested into the level n error
CIErrorManager	Interface for Kernel error handler implementationThis manager is reponsible for handling errors in the framework. Errors in the framework are considered as not acceptable behavior that can be detected and handled by the system. The concept of error is thus independant of warning or fatal crashes that must be handled separately
CIKernelContext	Kernel context interface, gives access to each manager the kernel owns
CIKernelDesc	A kernel description
CIKernelObject	Base class for all kernel objects
CIKernelObjectFactory	Kernel object factory, creates all kernel objects
CILink	Link information between OpenViBE boxThis class collects informations between OpenViBE boxes : box identifiers and input / output indices
CILogListener	Log manager's listener interface
CILogManager	Log manager
CIMessage	Base message class
CIMessageClock	Clock message
CIMessageEvent	Event message
CIMessageSignal	Signal message
CIMetaboxManager	Metabox manager
CIMetadata	Metadata class for scenarios
CIObjectVisitorContext	Exectution context for visitor objects
CIParameter	Generic parameter handler for configurable objects
CIPlayer	The main player classA player is responsible for the playback of a specific scenario. This player scenario is provided at initialisation stage and should not be changed until the player terminates. The player idea of calling a "play" function forces the use of threads in order to avoid CPU locking. Thus we prefer the idea of having a "short-time" function that is to be called repeatedly until the player terminates. This is the role of the IPlayer::loop function, that should be called repeatedly by the outside application
CIPlayerContext	Player interface for plugin objectsInstances of this class are given to plugin object so they can communicate with the platform kernel, providing services such as message sending etc..
CIPlayerManager	The manager responsible for scenario playbackThe player manager is responsible for creating the different player instances. Each player is responsible for the playback of a specific scenario
CIPluginManager	Log manager
CIPluginModule	Plugin module
CIPluginModuleContext	Plugin context
CIScenario	A static OpenViBE scenarioThis class is a static scenario description. It is used to manipulate an OpenViBE box/connection collection..
CIScenarioManager	The scenario managerThis manager is responsible to organize and handle all the scenarios of the kernel
CIServerExtensionContext	Static context of a Server Extension object
CIServerExtensionDynamicContext	Dynamic context of a Server Extension objectThis class contains accessors to data structures made available by the driver running in the Acquisition Server during the acquisition
CIServerExtensionProto	Prototype interface for a server extension
CITypeManager	Type manager, provides information on platform's handled types, parameters, streams etc..
CTParameterHandler	Helper class in order to manipulate IParameter and IParameter values natively
►NMetabox
CCMetaboxObjectDesc	The CMetaboxObjectDesc virtual BoxAlgorithmDesc for metaboxes
►NPlugins	Plugins specifications of the OpenViBE platform
CIAlgorithm	Abstract algorithm, base element of OpenViBE processing objectsThis class should be derived by any plugin that is related to data processing. It basically has a parameterable interface contained in the IAlgorithmContext object. This interface stores several typed parameters which can be modified either by outside world in order to provide input paramters to this algorithm or by this algorithm itself in order to produce output parameters
CIAlgorithmDesc	Algorithm plugin descriptorThis class should be derived by any plugin developer in order to describe a specific OpenViBE algorithm
CIBoxAlgorithm	Algorithm to create/process/transform OpenViBE dataThis class should be derived by any plugin that is related to data processing. It can be data acquisition/production from an hardware device or from a file. It can be data processing/transforming, moving time information into frequency space for example. It can be data classification generating discrete classification events better than continuous data flow
CIBoxAlgorithmDesc	Box algorithm plugin descriptorThis class should be derived by any plugin developer in order to describe a specific OpenViBE box algorithm
CIPluginObject	Base class for plugin objectThis class is the base class for all the concrete plugin classes that extend the OpenViBE platform. It comes with several basic functions each plugin should have in order to work in the OpenViBE platform
CIPluginObjectDesc	Base class for plugin descriptorThis class is the base class for all the plugin description classes. It contains basic functions that could be used for each plugin description. Derived plugin descriptions will be used as a prototype of what they can create
CCIdentifier	Globally used identification classThis class is the basic class to use in order to identify objects in the OpenViBE platform. It can be used for class identification, for object identification and any user needed identification process
CCMatrix	Basic standalone OpenViBE matrix implementationThis class offers a basic standalone impementation of the OpenViBE::IMatrix interface. This class can be directly instanciated and used
CCMemoryBuffer	Basic standalone OpenViBE memory buffer implementationThis class offers a basic standalone impementation of the OpenViBE::IMemoryBuffer interface. This class can be directly instanciated and used
CCNameValuePairList	This class handles a list of name/value pairs. It handles a (hidden) map associating string keys to string values.This class avoids the need to include stl's map header file in the C++ interface, thus preventing potential compile/link errors when dynamically loading modules
CCObservable	OpenViBE Observable class
CCommandFileParser	Parser implementation that parses command a fileThe current implementation retrieves the list of commands from a file
CCommandLineOptionParser	Parser implementation that parses command from command-line argumentsThe current implementation retrieves the options from a ProgramOptions parser and simply builds the commands from the parsed options
CCStimulationSet	Basic standalone OpenViBE stimulation set implementationThis class offers a basic standalone impementation of the OpenViBE::IStimulationSet interface. This class can be directly instanciated and used
CCString	String class to avoid std::string in the interfaceThis class helps avoiding std::string being present in exposed C++ interface, eventually resulting in compile/link errors when dynamically loading modules
CICommand	Base abstract struct for commandsA command is an object that encapsulates all necessary information to perform an action later one. Typically, a command implementation should contain an implementation of CommandInterface interface, and a list of properties
CICommandParser	Base abstract class for command parserCommand parsers aim at parsing a list of commands from a specific input
CIKernelLoader	This class allows an OpenViBE application to load a kernel module
CIMatrix	Basic OpenViBE matrix interface
CIMemoryBuffer	Basic OpenViBE memory buffer interface
CInitCommand	Command that drives the initialization of the toolInitCommand class contains the following properties:
CIObject	Base class for all the OpenViBE platform objects
CIObserver	OpenViBE Observer interface
CIStimulationSet	Basic OpenViBE stimulation set interface
CKernelFacade	Wrapper class used to access Kernel featuresThis class is one-to-many interface used as a central point to access a subset of Kernel features
CLoadKernelCommand	Command that drives kernel loadingLoadKernelCommand contains the following properties:
CLoadScenarioCommand	Command that drives scenario loadingLoadScenarioCommand contains the following properties:
►CProgramOptions	Command-line options parserThis class is a basic class used to parse program options. Input format requirements:
COptionDesc
CProgramOptionsTraits	Helper class for ProgramOptions type checkingThis class provides aliases to types currently handled by ProgramOptions class as well as type checking meta-programming features
CResetCommand	Command that drives tool reset to its initial state
CRunScenarioCommand	Command that drives the execution of a list of scenariosRunScenarioCommand contains the following properties:
CSetupScenarioCommand	Command that drives the setup of a scenarioSetupScenarioCommand contains the following properties:
▼NOpenViBEAcquisitionServer	Interface for acquisition server plugins
CIDriver	Base class for all the OpenViBE acquisition server drivers
CIDriverCallback	Base class for all the OpenViBE acquisition server driver callbacks
CIDriverContext	Base class for kernel functioanlities access from the driver classes
CIHeader	Base class for an OpenViBE header container
CProperty	Base class for properties. A property is essentially a <name,value> pair
▼NOpenViBETest
CScopedTest	Class used to ensure RAII when using TestFixture
CTestFixture	Base abstract struct for test fixture
▼NSocket
CIConnectionParallel	Possibility to communicate with a parallel port. On Windows, you must have TVicPort library installed (available for free: http://entechtaiwan.com/dev/port/index.shtm)
▼NSystem
CTime	Static functions to handle time within the framework
▼NXML
CIXMLHandler	This class is design to help about XML manipulation
CIXMLNode	Symbolize a node in a XML tree structure
CErrorType	List of error types
CGenericVRPNServer	A class providing a very simple generic VRPN server capable of creating Analog and Button controls
CReturnCode	Way of playing a scenario
CReturnCode	Scenario player list of potential return code