iLab Neuromorphic Robotics Toolkit  0.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages

#include <nrt/Core/Model/Component.H>

A component of a model hierarchy.

Model Components form the heart of every NRT application, as their main purpose is to allow a uniform interface for tunable Parameters. In fact, every class which needs to expose parameters to the user should inherit directly or inderectly from Component.

Components typically form a Component Hierarchy with a Manager at the top, and a tree of sub-Components below. To form this tree, just use the addSubComponent method to add some children, and then add some children to that child, etc...

Components are brought into action in several phases:

  • Construction: In constructors, Parameter values have not been set yet so nothing that depends on them should be initialized yet. Typically, constructors should only initialize fixed component resources which are independent of Parameter values, or they can also set default values for parameters, which may later be overriden by command-line arguments.
  • initialization: When init() is called on the manager, it will parse any command-line arguments and set Parameters accordingly, and it will then propagate down the entire component hierarchy. For each component, preInit() will be called first (and can be overloaded in derived Components), then init() will propagate to sub-components, and then postInit() will be called (and can be overloaded). Initialization is very similar to construction and is rarely used, the exception being for components that wish to initialize/free some resource even though they are not freshly constructed or about to be destructed yet, but they cannot rely on Parameter values being set yet. During initialization, some Parameter values may not have been set yet and thus Parameters should not be used. The init state is more relevant to Modules than raw Components: after init(), messages can already flow, in particular messages related to changing parameter values on remote modules, setting topics, etc. Before init, setting a Parameter value or setting a topic on a Module's port will not trigger a (time-consuming) update of the Blackboard federation, so remote blackboards and modules would not know yet about the parameter or topic value. They will know about it once init state is entered, though, so in general it is recommended that you set all your parameters and topics before init(), as setting them after init() will trigger potentially time-consuming Blackboard federation updates, recomputation of poster/subscriber topic matches, etc. Note that parsing command-line arguments and setting Parameter values accordingly happens in the preInit() of the Manager, so by the time init() propagates down to other Components this can be assumed to have been completed. After init() is completed, initialized() returns true; in more details:
  • start: When start() is called on the manager, it will propagate down the entire component hierarchy. For each component, preStart() will be called first (and can be overloaded in derived Components), then start() will propagate to sub-components, and then postStart() will be called (and can be overloaded). By the time preStart() is called, one can assume that all Parameters now have their final values, and Parameter-dependent resources can be allocated/started. In preStart(), subcomponents are not started yet, so you should assume that their paramaters are not fixed yet. In postStart(), all sub-components have been started and you can assume that their parameter values are finalized and their resources allocated/started. Note that if start() is called and init() has not been called yet, init() will automatically be called first. After start() is completed, started() returns true.
  • launch: After completion of the recursive start() call on the Manager, all Components are in started() state and upon calling launch() the Manager will now recurse through the Component tree again and call the run() function, if any, on each component in turn, each in its own parallel thread. Note that there is no preLaunch() / postLaunch() here as the run() function is available instead. If launch is called before start(), it will automatically call start() first. For basic users, this is the only function you only need to call, i.e., instantiate all your components and get them ready, then simply call launch() on the manager to get your model cranking. After launch(), running() will return true. More specifically, a two-stage process is triggered:
    • Subcomponents are launched first, and they are switched to running state;
    • then running() becomes true;
    • then the run() functions of sub-components (if any) are started in parallel threads
    • finally the run() function (if any) is started in a parallel tread. Note for Module objects (see Module.H), which derive from Component: You cannot post() or check() until the system is running(), attempting to do so will drop your messages. Indeed, in preInit(), prestart(), etc components are busy setting up and not all resources necessary for operation may be instantiated yet. This thus provides the following guarantee: it is safe in preStart(), postStart(), preStop(), postStop() to assume that all Parameter values are finalized and that no Message is flowing. Thus, this is where you should allocate/de-allocate all resources that depend on Parameter values. For example, a Component that holds an internal queue whose size can be set by the user via a Parameter should instantiate the queue during preStart() or postStart() (the choice here depends on whether sub-modules will need the queue or not), and should de-allocate the queue during preStop() or postStop(). It is guaranteed that no onMessage() callback will be triggered during these operations, so it is un-necessary in your onMessage() function to check whether the queue is already here, etc. you can assume it's here if you instantiate/de-allocate it as recommended here.
  • wait: run() functions may voluntarily decide that they are done, e.g., for a source Component when there is no more data to be sourced. Calling wait() on the manager will block until all run() functions thus exit.
  • stop: This is the dual of start(), with preStop() and postStop() following the same logic as preStart() and postStart(). Note that we do not pre-empt and interrupt any run() function here, so it is up to the programmer of each run() function to test periodically within the run() function whether running() is still true, and, if not, to exit the run() function. Beware that stop() will block until run() has exited, so do indeed make sure you check for running() an finish your run() function after running() has turned false. Specific order is:
    • running() turns to false
    • we wait for the run() function to complete, and propagate any exception that may be discovered;
    • preStop() is called (note that started() is still true at this point);
    • stop() is called on all subcomponents;
    • started() turns to false;
    • postStop() is called. If in doubt, overload postStop() and de-allocate your Parameter-dependent resources in there.
  • uninit: This is the dual of init(), with preUninit() and postUninit() following the same logic as preInit() and postInit(). Specific order is:

    See test-Component.C for examples.

See Also
ComponentSetupFunc
Examples:
tests/test-Component.C, tests/test-ImageReader.C, tests/test-Option.C, and tests/test-stream.C.

Definition at line 168 of file Component.H.

Inheritance diagram for nrt::Component:
nrt::ParameterRegistry nrt::graphics::Camera nrt::graphics::ImageRenderer nrt::graphics::ShapeRenderer nrt::ImageSinkType nrt::ImageSource nrt::ImageSourceBase nrt::Manager nrt::Module

Classes

struct  MetaInfo
 Meta-info about a Component derived class. More...
 

Public Member Functions

 Component (std::string const &instanceName)
 Constructor. More...
 
void prepareForDeletion ()
 Prepare for deletion: uninit and disconnect from our parent. More...
 
virtual ~Component ()
 Virtual destructor for safe inheritance. More...
 
template<>
std::shared_ptr< ComponentgetSubComponent (std::string const &instanceName) const
 
Component hierarchies
template<class Comp >
std::shared_ptr< Comp > addSubComponent (std::string const &instanceName="")
 Pseudo-constructor: construct and add another component as a subcomponent of this one. More...
 
template<class Comp >
void removeSubComponent (std::shared_ptr< Comp > &component)
 Remove a sub-Component from this Component, by shared_ptr. More...
 
void removeSubComponent (std::string const &instanceName)
 Remove a sub-Component from this Component, by instance name.
 
template<class Comp = nrt::Component>
std::shared_ptr< Comp > getSubComponent (std::string const &instanceName) const
 Get a sub-component by instance name. More...
 
bool isTopLevel () const
 Returns true if this component is top-level, i.e., its parent is an nrt::Manager (including nrt::Blackboard)
 
Component runtime
bool initialized () const
 Has this component been initialized yet?
 
bool started () const
 Is this component started, i.e., it has passed the start() state and not yet entered the stop() state.
 
bool running () const
 Is this component running, i.e., has passed start() and been launch()ed and not yet entered the stop() state.
 
void wait ()
 Wait until all run() functions decide on their own that they are finished. More...
 
Component metainfo-related functions
Component::MetaInfo const & meta () const
 Get the metainfo of this Component. More...
 
Component Parameter-related functions

Each Component can hold Parameter objects (through inheritance) that can be set externally by users to modify the operation of the Component.

template<typename T >
std::vector< std::string > setParamVal (std::string const &paramdescriptor, T const &val)
 Set a parameter value. More...
 
template<typename T >
void setParamValUnique (std::string const &paramdescriptor, T const &val)
 Set a parameter value, simple version assuming only one parameter match. More...
 
template<typename T >
std::vector< std::pair
< std::string, T > > 
getParamVal (std::string const &paramdescriptor) const
 Get parameter(s) value(s) by descriptor. More...
 
template<typename T >
getParamValUnique (std::string const &paramdescriptor) const
 Get a parameter value, simple version assuming only one parameter match. More...
 
std::vector< std::string > setParamString (std::string const &paramdescriptor, std::string const &val)
 Set a parameter value, by string. More...
 
void setParamStringUnique (std::string const &paramdescriptor, std::string const &val)
 Set a parameter value by string, simple version assuming only one parameter match. More...
 
std::vector< std::pair
< std::string, std::string > > 
getParamString (std::string const &paramdescriptor) const
 Get a parameter value, by string. More...
 
std::string getParamStringUnique (std::string const &paramdescriptor) const
 Get a parameter value by string, simple version assuming only one parameter match. More...
 
std::string descriptor () const
 Get our full descriptor (including all parents) as [Classname-Instancename]:[...]:[...].
 
std::string parentModuleUID () const
 Get the ModuleUID (as string) of this Component's nearest parent Module, or an empty string.
 
void prettyPrintTree (std::ostream &os, int indent=0) const
 Produce a nice textual hierarchy of this Component's sub-tree.
 
std::vector< std::pair
< std::string,
nrt::ParameterSummary > > 
getParamSummary (std::string const &paramdescriptor) const
 Return a list of parameter summaries for a given descriptor. More...
 
std::vector< std::pair
< std::string,
nrt::ParameterSummary > > 
getParamSummary (bool skipsubmodules=false) const
 Return a list of parameter summaries for all parameters of this Component and its subcomponents. More...
 
Component path-related functions

Each Component can keep track of a preferred filesystem path. Typically, users should not tamper with this, but Module objects (which derive from Component) that are dynamically loaded will have that path set to the path where the Module's shared object file (.so) was found. This allows those modules to access some of their local configuration data, which may, for example, be stored in an etc/ directory under the module path.

void setPath (std::string const &path)
 Assign a filesystem path to this component.
 
std::string absolutePath (std::string const &path)
 If given path is relative (not starting with /), prepend the Component path to it; otherwise, no-op.
 
- Public Member Functions inherited from nrt::ParameterRegistry
void addParameter (ParameterBase *const param)
 The parameter class uses this method to register itself on construction with it's owning Component.
 
void removeParameter (ParameterBase *const param)
 The parameter class uses this method to un-register itself on destruction with it's owning Component.
 

Protected Member Functions

Component setup functions overloadable by derived classes
virtual void preInit ()
 Called before all sub-Components are init()ed.
 
virtual void postInit ()
 Called after all sub-Components are init()ed.
 
virtual void preStart ()
 Called before all sub-Components are start()ed.
 
virtual void postStart ()
 Called after all sub-Components are start()ed.
 
virtual void run ()
 Called in its own thread after all Components have been start()ed. More...
 
virtual void preStop ()
 Called before all sub-Components are stop()ed.
 
virtual void postStop ()
 Called after all sub-Components are stop()ed.
 
virtual void preUninit ()
 Called before all sub-Components are uninit()ed.
 
virtual void postUninit ()
 Called after all sub-Components are uninit()ed.
 

Protected Attributes

boost::shared_mutex itsMtx
 Mutex used to protect our internals other than subcomponents and parameters.
 

Friends

class ParameterBase
 Create a message port for a Parameter of this Component (or sub-Component) More...
 
template<typename T >
class ParameterCore
 
class GenericLogger
 
class Manager
 
class Blackboard
 Allow Blackboard to access our step-by-step runstate functions directly.
 

Component misc protected functions

std::vector< std::shared_ptr
< Component > > 
itsSubComponents
 
boost::shared_mutex itsSubMtx
 
Component *const nrt_component_this
 
virtual void notifyAllParamChanged (nrt::ParameterState const state) const
 This method is called by the Blackboard to refresh a ParamChangedListener.
 
virtual void getAllParamSummaries (std::vector< nrt::ParameterSummary > &ps) const
 Recursively get all param summaries.
 
virtual void notifyParamChanged (nrt::ParameterState const state, ParameterBase const *const param) const
 This method is called by a Parameter when it has been changed. Users should never overload this method.
 
void populateHelpMessage (std::string const &cname, std::unordered_map< std::string, std::unordered_map< std::string, std::vector< std::pair< std::string, std::string > > > > &helplist) const
 

Constructor & Destructor Documentation

nrt::Component::Component ( std::string const &  instanceName)

Constructor.

The standard way to create a component is via Component::addSubComponent() or Manager::addComponent(), rather than constructing them by hand. Components constructed via the constructor (e.g., calling operator new) will not be attached to a Component hierarchy.

Parameters
instanceNameA string identifying a particular instance of a Component. This instance name should be passed in through your derived Component's constructor, allowing users to disambiguate between multiple instances of your Component. If the instance name is empty or NRT_AUTO_#, the actual instance will be names NRT_AUTO_# with # replaced by a number. The final name is accessible via Component::meta().instance once your component is constructed. There is no default value for instanceName in the base class to catch derived classes that forgot to pass it down to the base, but it may be a good idea to set an empty string default to instanceName in derived classes.
Examples:
tests/test-ImageReader.C, and tests/test-stream.C.
virtual nrt::Component::~Component ( )
virtual

Virtual destructor for safe inheritance.

Calls stop() if this module is started, and then uninit() if it is initialized.

Member Function Documentation

void nrt::Component::prepareForDeletion ( )

Prepare for deletion: uninit and disconnect from our parent.

Normal users do not need to call this, the destructor automatically does.

template<class Comp >
std::shared_ptr< Comp > nrt::Component::addSubComponent ( std::string const &  instanceName = "")
inline

Pseudo-constructor: construct and add another component as a subcomponent of this one.

A child component of type Comp (which must derive from nrt::Component) will be created and added as a sub-component of this. The child logically "belongs" to this component, and will automatically be deleted when the parent component is deleted. In addition to construction, adding a subcomponent has the following effects:

  • subComp will be start()ed after this Component's preStart() but before this Component's postStart(), and idem for init().
  • subComp will be stop()ed after this Component's preStop() but before this Component's postStop(), idem for uninit().
  • When setting parameters, the sub-Component can be referenced as a child of this component. For instance, if we have a ComponentParent which has ComponentChild as a sub-Component, and ComponentChild has parameter named coolChildParam, then that parameter could be specified on the command line by
    --ComponentParent:ComponentChild:coolChildParam="whatever"

Definition at line 74 of file ComponentImpl.H.

References NRT_FATAL, and NRT_MODDEBUG.

template<class Comp >
void nrt::Component::removeSubComponent ( std::shared_ptr< Comp > &  component)

Remove a sub-Component from this Component, by shared_ptr.

Note
Beware that the passed shared_ptr is invalidated in the process. A warning is issued if the use_count is not down to zero after that (i.e., there are additional shared_ptr pointers to this Component floating around, which prevent it from actually being deleted.

Definition at line 154 of file ComponentImpl.H.

References NRT_MODDEBUG, and NRT_WARNING.

template<class Comp >
std::shared_ptr< Comp > nrt::Component::getSubComponent ( std::string const &  instanceName) const
inline

Get a sub-component by instance name.

This method does a dynamic_pointer_cast to Comp if it is not the default (nrt::Component). Throws if component is not found by instance name, or it is found but not of type Comp (if Comp is specified). Note that once you hold a shared_ptr to a Component, it is guaranteed that the component will not be destroyed until that shared_ptr is released. If the NRT system tries to destroy the component (e.g., someone calls removeSubComponent()), the component will be un-initialized and its parent will be unset, so it will not be fully operational and will be actually deleted when the last shared_ptr to it runs out of scope.

Definition at line 115 of file ComponentImpl.H.

References NRT_FATAL.

void nrt::Component::wait ( )

Wait until all run() functions decide on their own that they are finished.

This differs from stop() in that stop() will set running() to false, which proper run() functions should periodically check for and quit if running() has turned false. In addition, run() functions may also decide to terminate on their own, e.g., in an ImageSource when there are no more frames. In such case, one should call wait() here as a substitute for a while(1) loop in main().

Examples:
tests/test-TransformManager.C.
nrt::Component::MetaInfo const & nrt::Component::meta ( ) const
inline

Get the metainfo of this Component.

Note
Always use meta() and not itsMetaInfo, because meta() will guarantee that the class name is set.
Examples:
tests/test-ResultsSyntax.C.

Definition at line 45 of file ComponentImpl.H.

References nrt::Component::MetaInfo::className, and nrt::demangle().

template<typename T >
std::vector< std::string > nrt::Component::setParamVal ( std::string const &  paramdescriptor,
T const &  val 
)
inline

Set a parameter value.

Throws if we don't have a parameter by that name or the value does not work out. Here is how the descriptor works:

The basic format is

[Classname-Instancename]:[...]:[paramname]

If you only specify paramname, then the param must exist in this component. If you specify a bunch of Classname-Instancename, then we will look for that param in a subcomponent. Note that Classname-Instancename is a loose requirement, you could have just the Classname (possibly with namespaces, subclass, etc in which case use :: as in C++), or just the Instancename, or both separated by a '-'. When parsing it we look for the first '-', and if there is none we try to match against either Classname or Instancename of the component, while if there is one or more we try to match Classname-Instancename or also just Instancename (in case your instance name contains dashes too). This is robust except in the funky situation where your instance name has a dash in it and the word before the dash happens to match your class name, so just avoid that (eg, avoid dashes and class names in your instance names).

Now that [Classname-Instancename] token can also be replaced by a *, which is equivalent to any number of any Classname-Instancename specifications. So use the * to reach parameters when you don't know how deep they are. If there is some other Classname-Instancename between a * and the final paramname, then recursion is turned off and anything between the * and paramname must match intervening components/instances.

For example,

MyInst:*:CoolClass:MyParam

would match parameters where MyInst matches the top-level component (the one on which you call setParamVal()), then would recurse through any number of subcomponents, until one of them matches CoolClass, and then we would look for MyParam parameter in that subcomponent, and we would not look any deeper. You may want to play with test-Component to try different scenarios.

Finally note that there is an implicit first *: that is automatically prepended to your description, so if you just specify a paramname and nothing else before it, we will set all params by that name in all subcomponents no matter how deep they are (as if you had specified *:paramname).

Exceptions
nrt::exception::ParameterExceptionif no Parameter matches the given descriptor.
Returns
list of fully-unrolled (no '*') descriptors of the parameters that were matched and set. The list is guaranteed to have at least one element since we throw if no matching parameter is found.
Examples:
tests/test-Module.C, tests/test-split-messages.C, and tests/test-TransformManager.C.

Definition at line 190 of file ComponentImpl.H.

References nrt::ParameterCore< T >::set().

Referenced by main(), and setParamValUnique().

template<typename T >
void nrt::Component::setParamValUnique ( std::string const &  paramdescriptor,
T const &  val 
)
inline

Set a parameter value, simple version assuming only one parameter match.

This calls setParamVal(), and checks that exactly one match was found.

Exceptions
nrt::exception::ParameterExceptionif not exactly one Parameter matches the given descriptor.

Definition at line 213 of file ComponentImpl.H.

References setParamVal().

template<typename T >
std::vector< std::pair< std::string, T > > nrt::Component::getParamVal ( std::string const &  paramdescriptor) const
inline

Get parameter(s) value(s) by descriptor.

Use this method to get the current value of a Component's parameter from the string descriptor. Values for all parameters that match the descriptor are returned.

For example, if the class MyComponent has an integer parameter named "myparam" you could get the value like so:

std::shared_ptr<MyComponent> comp(new MyComponent);
auto paramValues = comp->getParamVal<int>("myparam");
for (auto const & pp : paramValues) NRT_INFO("Parameter " << pp.first << " = " << pp.second);
Exceptions
nrt::exception::ParameterExceptionif no Parameter matches the given descriptor.
Returns
list of <paramdescriptor, value> for all parameters that matched the given descriptor. The list is guaranteed to have at least one element since we throw if no matching parameter is found.
See Also
setParamVal for a detailed explanation of the paramdescriptor

Definition at line 224 of file ComponentImpl.H.

References nrt::ParameterCore< T >::get().

template<typename T >
T nrt::Component::getParamValUnique ( std::string const &  paramdescriptor) const
inline

Get a parameter value, simple version assuming only one parameter match.

This calls getParamVal(), checks that exactly one match was found, and returns its value. For example, if the class MyComponent has an integer parameter named "myparam" you could get the value like so:

std::shared_ptr<MyComponent> comp(new MyComponent);
int paramValue = comp->getUniqueParamVal<int>("myparam");
Exceptions
nrt::exception::ParameterExceptionif not exactly one Parameter matches the given descriptor.

Definition at line 246 of file ComponentImpl.H.

References descriptor().

std::vector<std::string> nrt::Component::setParamString ( std::string const &  paramdescriptor,
std::string const &  val 
)

Set a parameter value, by string.

See Also
setParamVal for a detailed explanation of the paramdescriptor
Exceptions
nrt::exception::ParameterExceptionif no Parameter matches the given descriptor or if the given string cannot be converted to the Parameter's native type.
Returns
list of fully-unrolled (no '*') descriptors of the parameters that were matched and set. The list is guaranteed to have at least one element since we throw if no matching parameter is found.
void nrt::Component::setParamStringUnique ( std::string const &  paramdescriptor,
std::string const &  val 
)

Set a parameter value by string, simple version assuming only one parameter match.

This calls setParamVal(), and checks that exactly one match was found.

Exceptions
nrt::exception::ParameterExceptionif not exactly one Parameter matches the given descriptor.
std::vector<std::pair<std::string, std::string> > nrt::Component::getParamString ( std::string const &  paramdescriptor) const

Get a parameter value, by string.

See Also
setParamVal for a detailed explanation of the paramdescriptor Use this method to get the current value of a Component's Component parameter-related classes and functions from the string descriptor. Values for all parameters that match the descriptor are returned, as string.
Exceptions
nrt::exception::ParameterExceptionif no Parameter matches the given descriptor.
Returns
list of <paramdescriptor, valuestring> for all parameters that matched the given descriptor. The list is guaranteed to have at least one element since we throw if no matching parameter is found.
std::string nrt::Component::getParamStringUnique ( std::string const &  paramdescriptor) const

Get a parameter value by string, simple version assuming only one parameter match.

This calls getParamVal(), checks that exactly one match was found, and returns its value as a string.

Exceptions
nrt::exception::ParameterExceptionif not exactly one Parameter matches the given descriptor.
std::vector<std::pair<std::string, nrt::ParameterSummary> > nrt::Component::getParamSummary ( std::string const &  paramdescriptor) const

Return a list of parameter summaries for a given descriptor.

See Also
setParamVal for a detailed explanation of the paramdescriptor. This is like getParamString() but returns Component parameter-related classes and functions summaries instead of just values.
std::vector<std::pair<std::string, nrt::ParameterSummary> > nrt::Component::getParamSummary ( bool  skipsubmodules = false) const

Return a list of parameter summaries for all parameters of this Component and its subcomponents.

This just aggregates the summaries for all parameters of the component and (recursively) its subcomponents (possibly restricting to only sub-components that are not of Module type; in such case it is assumed that one would call this function on each Module in a collection). The results are indexed by unrolled parameter descriptor, as in getParamString().

virtual void nrt::Component::run ( )
inlineprotectedvirtual

Called in its own thread after all Components have been start()ed.

If your Component has some work to do at runtime, you can put that functionality into the run() function. Every Component's run() method will be spawned in a new thread as soon as the start() process has completed. In run(), you should periodically test whether running() is true, and, if not, that means that stop() has been called and you should then exit the run() function as soon as practical.

So the typical form of a run() function is as follows:

void MyComponent::run()
{
// Do one-time things that require us to be running(), for example, post some one-time message, etc
// Loop while we are still running. Make sure that your loop is relatively fast, as if it takes a long time,
// users will have to wait for it when they attempt to stop a running system. In particuler, beware of
// blocking on producer/consumer queues, waiting for I/O, etc and make sure you use functions with timeouts
// for these kinds of things.
while (running())
{
// do a bunch of things like, e.g., read some data from a device and post it
}
// Do final cleanups, e.g., close resources opened before our while loop
}

Reimplemented in nrt::OpenNIImageSource.

Examples:
tests/test-Component.C, and tests/test-TransformManager.C.

Definition at line 493 of file Component.H.

Friends And Related Function Documentation

friend class ParameterBase
friend

Create a message port for a Parameter of this Component (or sub-Component)

Requires initialized() or more because you need to be able to post(), check(), etc by the time you create ports for your parameter.

Exceptions
nrt::exception::ParameterExceptionif the parameter is not found.
Returns
list of param descriptors that matched. Delete a message port for a Parameter of this Component (or sub-Component)

Note that we will automatically delete the ports during uninit() because they cannot be allowed to exist and post(), check(), etc if we are not initialized.

Exceptions
nrt::exception::ParameterExceptionif the port is not found, eg, it has not been created.
Returns
list of param descriptors that matched. Set the topic of a Parameter Poster
Precondition
Requires initialized() or more.
Exceptions
nrt::exception::ParameterExceptionif the poster is not found, eg, it has not been created. Set the topic filter of a Parameter Checker
Precondition
Requires initialized() or more.
Exceptions
nrt::exception::ParameterExceptionif the checker is not found, eg, it has not been created. Set the topic filter of a Parameter Subscriber
Precondition
Requires initialized() or more.
Exceptions
nrt::exception::ParameterExceptionif the subscriber is not found, eg, it has not been created.

Definition at line 576 of file Component.H.


The documentation for this class was generated from the following files: