cisst-saw
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Friends | List of all members
mtsInterfaceRequired Class Reference
cisstMultiTask

#include <mtsInterfaceRequired.h>

Inheritance diagram for mtsInterfaceRequired:
mtsInterface cmnGenericObject

Classes

class  FunctionOrReceiverInfo

Public Types

enum  { DEFAULT_MAIL_BOX_AND_ARGUMENT_QUEUES_SIZE = 64 }
typedef FunctionOrReceiverInfo< mtsFunctionBase > FunctionInfo
typedef FunctionOrReceiverInfo< mtsEventReceiverVoid > ReceiverVoidInfo
typedef FunctionOrReceiverInfo< mtsEventReceiverWrite > ReceiverWriteInfo

Public Member Functions

 mtsInterfaceRequired (const std::string &interfaceName, mtsComponent *component, mtsMailBox *mailBox, mtsRequiredType required=MTS_REQUIRED)
virtual ~mtsInterfaceRequired ()
const mtsInterfaceProvided * GetConnectedInterface (void) const
bool SetMailBoxSize (size_t desiredSize)
bool SetArgumentQueuesSize (size_t desiredSize)
bool SetMailBoxAndArgumentQueuesSize (size_t desiredSize)
ConnectionIDType GetConnectionID (void) const
mtsInterfaceRequiredDescription GetDescription () const
virtual std::vector< std::string > GetNamesOfFunctions (void) const
virtual std::vector< std::string > GetNamesOfFunctionsVoid (void) const
virtual std::vector< std::string > GetNamesOfFunctionsVoidReturn (void) const
virtual std::vector< std::string > GetNamesOfFunctionsWrite (void) const
virtual std::vector< std::string > GetNamesOfFunctionsWriteReturn (void) const
virtual std::vector< std::string > GetNamesOfFunctionsRead (void) const
virtual std::vector< std::string > GetNamesOfFunctionsQualifiedRead (void) const
mtsFunctionVoid * GetFunctionVoid (const std::string &functionName) const
mtsFunctionVoidReturn * GetFunctionVoidReturn (const std::string &functionName) const
mtsFunctionWrite * GetFunctionWrite (const std::string &functionName) const
mtsFunctionWriteReturn * GetFunctionWriteReturn (const std::string &functionName) const
mtsFunctionRead * GetFunctionRead (const std::string &functionName) const
mtsFunctionQualifiedRead * GetFunctionQualifiedRead (const std::string &functionName) const
virtual std::vector< std::string > GetNamesOfEventHandlersVoid (void) const
virtual std::vector< std::string > GetNamesOfEventHandlersWrite (void) const
virtual mtsCommandVoid * GetEventHandlerVoid (const std::string &eventName) const
virtual mtsCommandWriteBase * GetEventHandlerWrite (const std::string &eventName) const
bool ConnectTo (mtsInterfaceProvided *interfaceProvided)
mtsRequiredType IsRequired (void) const
bool AddSystemEventHandlers (void)
void DisableAllEvents (void)
void EnableAllEvents (void)
size_t ProcessMailBoxes (void)
void ToStream (std::ostream &outputStream) const override
bool AddFunction (const std::string &functionName, mtsFunctionVoid &function, mtsRequiredType required=MTS_REQUIRED)
bool AddFunction (const std::string &functionName, mtsFunctionVoidReturn &function, mtsRequiredType required=MTS_REQUIRED)
bool AddFunction (const std::string &functionName, mtsFunctionWrite &function, mtsRequiredType required=MTS_REQUIRED)
bool AddFunction (const std::string &functionName, mtsFunctionWriteReturn &function, mtsRequiredType required=MTS_REQUIRED)
bool AddFunction (const std::string &functionName, mtsFunctionRead &function, mtsRequiredType required=MTS_REQUIRED)
bool AddFunction (const std::string &functionName, mtsFunctionQualifiedRead &function, mtsRequiredType required=MTS_REQUIRED)
bool AddEventReceiver (const std::string &eventName, mtsEventReceiverVoid &receiver, mtsRequiredType required=MTS_REQUIRED)
bool AddEventReceiver (const std::string &eventName, mtsEventReceiverWrite &receiver, mtsRequiredType required=MTS_REQUIRED)
mtsCommandVoid * AddEventHandlerVoid (mtsCallableVoidBase *callable, const std::string &eventName, mtsEventQueueingPolicy queueingPolicy=MTS_INTERFACE_EVENT_POLICY)
template<class __classType>
mtsCommandVoid * AddEventHandlerVoid (void(__classType::*method)(void), __classType *classInstantiation, const std::string &eventName, mtsEventQueueingPolicy queueingPolicy=MTS_INTERFACE_EVENT_POLICY)
mtsCommandVoid * AddEventHandlerVoid (void(*function)(void), const std::string &eventName, mtsEventQueueingPolicy queueingPolicy=MTS_INTERFACE_EVENT_POLICY)
template<class __classType, class __argumentType>
mtsCommandWriteBase * AddEventHandlerWrite (void(__classType::*method)(const __argumentType &), __classType *classInstantiation, const std::string &eventName, mtsEventQueueingPolicy queueingPolicy=MTS_INTERFACE_EVENT_POLICY)
template<class __classType>
mtsCommandWriteBase * AddEventHandlerWriteGeneric (void(__classType::*method)(const mtsGenericObject &), __classType *classInstantiation, const std::string &eventName, mtsEventQueueingPolicy queueingPolicy=MTS_INTERFACE_EVENT_POLICY, mtsGenericObject *argumentPrototype=0)
bool RemoveEventHandlerVoid (const std::string &eventName)
bool RemoveEventHandlerWrite (const std::string &eventName)
Public Member Functions inherited from mtsInterface
 mtsInterface (const std::string &interfaceName, mtsComponent *component)
virtual ~mtsInterface ()
const std::string & GetName (void) const
const std::string GetFullName (void) const
const mtsComponent * GetComponent (void) const
const std::string & GetComponentName (void) const
void AddTag (const std::string &tag)
const std::set< std::string > & GetTags (void) const
Public Member Functions inherited from cmnGenericObject
virtual ~cmnGenericObject (void)
virtual const cmnClassServicesBase * Services (void) const =0
bool ReconstructFrom (const cmnGenericObject &other)
std::string ToString (void) const
virtual void ToStreamRaw (std::ostream &outputStream, const char delimiter=' ', bool headerOnly=false, const std::string &headerPrefix="") const
virtual bool FromStreamRaw (std::istream &inputStream, const char delimiter=' ')
virtual void SerializeRaw (std::ostream &outputStream) const
virtual void DeSerializeRaw (std::istream &inputStream)
virtual cmnLogger::StreamBufType * GetLogMultiplexer (void) const
virtual size_t ScalarNumber (void) const
virtual bool ScalarNumberIsFixed (void) const
virtual double Scalar (const size_t CMN_UNUSED(index)) const CISST_THROW(std
virtual std::string ScalarDescription (const size_t CMN_UNUSED(index), const std::string &CMN_UNUSED(userDescription)) const

Protected Types

typedef cmnNamedMap< FunctionInfo > FunctionInfoMapType
typedef cmnNamedMap< ReceiverVoidInfo > EventReceiverVoidMapType
typedef cmnNamedMap< ReceiverWriteInfo > EventReceiverWriteMapType
typedef cmnNamedMap< mtsCommandVoid > EventHandlerVoidMapType
typedef cmnNamedMap< mtsCommandWriteBase > EventHandlerWriteMapType

Protected Member Functions

 mtsInterfaceRequired (void)
osaThreadSignal * GetThreadSignal (void)
bool UseQueueBasedOnInterfacePolicy (mtsEventQueueingPolicy queueingPolicy, const std::string &methodName, const std::string &eventName)
bool AddEventHandlerToReceiver (const std::string &eventName, mtsCommandVoid *handler) const
bool AddEventHandlerToReceiver (const std::string &eventName, mtsCommandWriteBase *handler) const
void GetDescription (mtsInterfaceRequiredDescription &requiredInterfaceDescription) const
Protected Member Functions inherited from mtsInterface
void Initialize (void)

Protected Attributes

mtsRequiredType Required
mtsMailBox * MailBox
const mtsInterfaceProvided * InterfaceProvided
size_t MailBoxSize
size_t ArgumentQueuesSize
ConnectionIDType ConnectionID
osaThreadSignal ThreadSignalForBlockingCommands
FunctionInfoMapType FunctionsVoid
FunctionInfoMapType FunctionsVoidReturn
FunctionInfoMapType FunctionsWrite
FunctionInfoMapType FunctionsWriteReturn
FunctionInfoMapType FunctionsRead
FunctionInfoMapType FunctionsQualifiedRead
EventReceiverVoidMapType EventReceiversVoid
EventReceiverWriteMapType EventReceiversWrite
EventHandlerVoidMapType EventHandlersVoid
EventHandlerWriteMapType EventHandlersWrite
Protected Attributes inherited from mtsInterface
const std::string Name
mtsComponent * Component
std::set< std::string > mTags

Friends

class mtsManagerLocal
class mtsEventReceiverBase
class mtsManagerComponent
class mtsSocketProxyClient
class mtsSocketProxyServer

Detailed Description

This class implements the required interface for a component (mtsComponent, mtsTask, ...). The required interface gets populated with pointers to command objects, which have four signatures:

Void: no parameters Read: one non-const parameter Write: one const parameter QualifiedRead: one non-const (read) and one const (write) parameter

The required interface may also have command object pointers for the following types of event handlers:

Void: no parameters Write: one const parameter

When the required interface of this component is connected to the provided interface of another component, the command object pointers are "bound" to command objects provided by the other component. Similarly, the event handlers are added as observers of events that are generated by the provided interface of the other component.

This implementation is simpler than the provided interface because we assume that a required interface is never connected to more than one provided interface, whereas a provided interface can be used by multiple required interfaces. While one can conceive of cases where it may be useful to have a required interface connect to multiple provided interfaces (e.g., running a robot simulation in parallel with a real robot), at this time it is not worth the trouble.

Member Typedef Documentation

◆ EventHandlerVoidMapType

typedef cmnNamedMap<mtsCommandVoid> mtsInterfaceRequired::EventHandlerVoidMapType
protected

Typedef for a map of event name and event handler (command object).

◆ EventHandlerWriteMapType

typedef cmnNamedMap<mtsCommandWriteBase> mtsInterfaceRequired::EventHandlerWriteMapType
protected

◆ EventReceiverVoidMapType

typedef cmnNamedMap<ReceiverVoidInfo> mtsInterfaceRequired::EventReceiverVoidMapType
protected

◆ EventReceiverWriteMapType

typedef cmnNamedMap<ReceiverWriteInfo> mtsInterfaceRequired::EventReceiverWriteMapType
protected

◆ FunctionInfo

typedef FunctionOrReceiverInfo<mtsFunctionBase> mtsInterfaceRequired::FunctionInfo

◆ FunctionInfoMapType

typedef cmnNamedMap<FunctionInfo> mtsInterfaceRequired::FunctionInfoMapType
protected

◆ ReceiverVoidInfo

typedef FunctionOrReceiverInfo<mtsEventReceiverVoid> mtsInterfaceRequired::ReceiverVoidInfo

◆ ReceiverWriteInfo

typedef FunctionOrReceiverInfo<mtsEventReceiverWrite> mtsInterfaceRequired::ReceiverWriteInfo

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Default size for mail boxes and argument queues used by event handlers.

Enumerator
DEFAULT_MAIL_BOX_AND_ARGUMENT_QUEUES_SIZE 

Constructor & Destructor Documentation

◆ mtsInterfaceRequired() [1/2]

mtsInterfaceRequired::mtsInterfaceRequired ( void )
protected

Default constructor. Does nothing, should not be used.

◆ mtsInterfaceRequired() [2/2]

mtsInterfaceRequired::mtsInterfaceRequired ( const std::string & interfaceName,
mtsComponent * component,
mtsMailBox * mailBox,
mtsRequiredType required = MTS_REQUIRED )

Constructor. Sets the name, device pointer, and mailbox for queued events.

Parameters
interfaceNameName of required interface
mboxMailbox to use for queued events (for tasks); set to 0 for devices (i.e. mtsComponent) while tasks (derived from mtsTask) create a mailbox and then provide the mailbox to the required interface.
isRequiredUsed to indicate if the component should function even if this interface is not connected to a provided interface.

◆ ~mtsInterfaceRequired()

virtual mtsInterfaceRequired::~mtsInterfaceRequired ( )
virtual

Default destructor.

Member Function Documentation

◆ AddEventHandlerToReceiver() [1/2]

bool mtsInterfaceRequired::AddEventHandlerToReceiver ( const std::string & eventName,
mtsCommandVoid * handler ) const
protected

◆ AddEventHandlerToReceiver() [2/2]

bool mtsInterfaceRequired::AddEventHandlerToReceiver ( const std::string & eventName,
mtsCommandWriteBase * handler ) const
protected

◆ AddEventHandlerVoid() [1/3]

mtsCommandVoid * mtsInterfaceRequired::AddEventHandlerVoid ( mtsCallableVoidBase * callable,
const std::string & eventName,
mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY )

◆ AddEventHandlerVoid() [2/3]

mtsCommandVoid * mtsInterfaceRequired::AddEventHandlerVoid ( void(* function )(void),
const std::string & eventName,
mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY )
inline

◆ AddEventHandlerVoid() [3/3]

template<class __classType>
mtsCommandVoid * mtsInterfaceRequired::AddEventHandlerVoid ( void(__classType::* method )(void),
__classType * classInstantiation,
const std::string & eventName,
mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY )
inline

◆ AddEventHandlerWrite()

template<class __classType, class __argumentType>
mtsCommandWriteBase * mtsInterfaceRequired::AddEventHandlerWrite ( void(__classType::* method )(const __argumentType &),
__classType * classInstantiation,
const std::string & eventName,
mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY )
inline

◆ AddEventHandlerWriteGeneric()

template<class __classType>
mtsCommandWriteBase * mtsInterfaceRequired::AddEventHandlerWriteGeneric ( void(__classType::* method )(const mtsGenericObject &),
__classType * classInstantiation,
const std::string & eventName,
mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY,
mtsGenericObject * argumentPrototype = 0 )
inline

◆ AddEventReceiver() [1/2]

bool mtsInterfaceRequired::AddEventReceiver ( const std::string & eventName,
mtsEventReceiverVoid & receiver,
mtsRequiredType required = MTS_REQUIRED )

◆ AddEventReceiver() [2/2]

bool mtsInterfaceRequired::AddEventReceiver ( const std::string & eventName,
mtsEventReceiverWrite & receiver,
mtsRequiredType required = MTS_REQUIRED )

◆ AddFunction() [1/6]

bool mtsInterfaceRequired::AddFunction ( const std::string & functionName,
mtsFunctionQualifiedRead & function,
mtsRequiredType required = MTS_REQUIRED )

◆ AddFunction() [2/6]

bool mtsInterfaceRequired::AddFunction ( const std::string & functionName,
mtsFunctionRead & function,
mtsRequiredType required = MTS_REQUIRED )

◆ AddFunction() [3/6]

bool mtsInterfaceRequired::AddFunction ( const std::string & functionName,
mtsFunctionVoid & function,
mtsRequiredType required = MTS_REQUIRED )

◆ AddFunction() [4/6]

bool mtsInterfaceRequired::AddFunction ( const std::string & functionName,
mtsFunctionVoidReturn & function,
mtsRequiredType required = MTS_REQUIRED )

◆ AddFunction() [5/6]

bool mtsInterfaceRequired::AddFunction ( const std::string & functionName,
mtsFunctionWrite & function,
mtsRequiredType required = MTS_REQUIRED )

◆ AddFunction() [6/6]

bool mtsInterfaceRequired::AddFunction ( const std::string & functionName,
mtsFunctionWriteReturn & function,
mtsRequiredType required = MTS_REQUIRED )

◆ AddSystemEventHandlers()

bool mtsInterfaceRequired::AddSystemEventHandlers ( void )
Todo
update documentation Bind command and events. This method needs to provide a user Id so that GetCommandVoid and GetCommandWrite (queued commands) know which mailbox to use. The user Id is provided by the provided interface when calling AllocateResources.

◆ ConnectTo()

bool mtsInterfaceRequired::ConnectTo ( mtsInterfaceProvided * interfaceProvided)

◆ DisableAllEvents()

void mtsInterfaceRequired::DisableAllEvents ( void )

◆ EnableAllEvents()

void mtsInterfaceRequired::EnableAllEvents ( void )

◆ GetConnectedInterface()

const mtsInterfaceProvided * mtsInterfaceRequired::GetConnectedInterface ( void ) const

◆ GetConnectionID()

ConnectionIDType mtsInterfaceRequired::GetConnectionID ( void ) const
inline

◆ GetDescription() [1/2]

mtsInterfaceRequiredDescription mtsInterfaceRequired::GetDescription ( ) const

Get the description of this interface.

◆ GetDescription() [2/2]

void mtsInterfaceRequired::GetDescription ( mtsInterfaceRequiredDescription & requiredInterfaceDescription) const
protected

Get description of this interface (with serialized argument information)

◆ GetEventHandlerVoid()

virtual mtsCommandVoid * mtsInterfaceRequired::GetEventHandlerVoid ( const std::string & eventName) const
virtual

Find an event handler based on its name.

◆ GetEventHandlerWrite()

virtual mtsCommandWriteBase * mtsInterfaceRequired::GetEventHandlerWrite ( const std::string & eventName) const
virtual

◆ GetFunctionQualifiedRead()

mtsFunctionQualifiedRead * mtsInterfaceRequired::GetFunctionQualifiedRead ( const std::string & functionName) const

◆ GetFunctionRead()

mtsFunctionRead * mtsInterfaceRequired::GetFunctionRead ( const std::string & functionName) const

◆ GetFunctionVoid()

mtsFunctionVoid * mtsInterfaceRequired::GetFunctionVoid ( const std::string & functionName) const

Find a function based on its name.

◆ GetFunctionVoidReturn()

mtsFunctionVoidReturn * mtsInterfaceRequired::GetFunctionVoidReturn ( const std::string & functionName) const

◆ GetFunctionWrite()

mtsFunctionWrite * mtsInterfaceRequired::GetFunctionWrite ( const std::string & functionName) const

◆ GetFunctionWriteReturn()

mtsFunctionWriteReturn * mtsInterfaceRequired::GetFunctionWriteReturn ( const std::string & functionName) const

◆ GetNamesOfEventHandlersVoid()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfEventHandlersVoid ( void ) const
virtual

Get the names of event handlers that exist in this interface

◆ GetNamesOfEventHandlersWrite()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfEventHandlersWrite ( void ) const
virtual

◆ GetNamesOfFunctions()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctions ( void ) const
virtual

Get the names of commands required by this interface.

◆ GetNamesOfFunctionsQualifiedRead()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctionsQualifiedRead ( void ) const
virtual

◆ GetNamesOfFunctionsRead()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctionsRead ( void ) const
virtual

◆ GetNamesOfFunctionsVoid()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctionsVoid ( void ) const
virtual

◆ GetNamesOfFunctionsVoidReturn()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctionsVoidReturn ( void ) const
virtual

◆ GetNamesOfFunctionsWrite()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctionsWrite ( void ) const
virtual

◆ GetNamesOfFunctionsWriteReturn()

virtual std::vector< std::string > mtsInterfaceRequired::GetNamesOfFunctionsWriteReturn ( void ) const
virtual

◆ GetThreadSignal()

osaThreadSignal * mtsInterfaceRequired::GetThreadSignal ( void )
protected

For event receiver.

◆ IsRequired()

mtsRequiredType mtsInterfaceRequired::IsRequired ( void ) const

Check if this interface is required or not for the component to function.

◆ ProcessMailBoxes()

size_t mtsInterfaceRequired::ProcessMailBoxes ( void )

Process any queued events.

◆ RemoveEventHandlerVoid()

bool mtsInterfaceRequired::RemoveEventHandlerVoid ( const std::string & eventName)

◆ RemoveEventHandlerWrite()

bool mtsInterfaceRequired::RemoveEventHandlerWrite ( const std::string & eventName)

◆ SetArgumentQueuesSize()

bool mtsInterfaceRequired::SetArgumentQueuesSize ( size_t desiredSize)

Set the desired size for all argument queues. If queueing has been enabled for this interface, each write event handler manages it's own queue of arguments. The command itself is queued in the interface mailbox (see SetMailBoxSize) and the argument is queued by the command itself. There is no reason to have an argument queue larger than the event handlers mail box as there can't be more arguments queued than events. The reciprocal is not true as different events can be queued. So, the argument queue size should be lesser or equal to the mail box size.

The size of the mail box can't be changed while being used (i.e. while this required interface is connected to a provided interface.

◆ SetMailBoxAndArgumentQueuesSize()

bool mtsInterfaceRequired::SetMailBoxAndArgumentQueuesSize ( size_t desiredSize)

Set the desired size for the event handlers mail box and argument queues. See SetMailBoxSize and SetArgumentQueuesSize.

◆ SetMailBoxSize()

bool mtsInterfaceRequired::SetMailBoxSize ( size_t desiredSize)

Set the desired size for the event handlers mail box. If queueing has been enabled for this interface, a single mailbox is created to handle all events. Each write event handler manages it's own queue for the event argument. To change the argument queue size, use SetArgumentQueuesSize. To change both parameters at once, use SetMailBoxAndArgumentQueuesSize.

The size of the mail box can't be changed while being used (i.e. while this required interface is connected to a provided interface.

◆ ToStream()

void mtsInterfaceRequired::ToStream ( std::ostream & outputStream) const
overridevirtual

Send a human readable description of the interface.

Reimplemented from cmnGenericObject.

◆ UseQueueBasedOnInterfacePolicy()

bool mtsInterfaceRequired::UseQueueBasedOnInterfacePolicy ( mtsEventQueueingPolicy queueingPolicy,
const std::string & methodName,
const std::string & eventName )
protected

Utility method to determine if an event handler should be queued or not based on the default policy for the interface and the user's requested policy. This method also generates a warning or error in the log if needed.

◆ mtsEventReceiverBase

friend class mtsEventReceiverBase
friend

◆ mtsManagerComponent

friend class mtsManagerComponent
friend

◆ mtsManagerLocal

friend class mtsManagerLocal
friend

◆ mtsSocketProxyClient

friend class mtsSocketProxyClient
friend

◆ mtsSocketProxyServer

friend class mtsSocketProxyServer
friend

Member Data Documentation

◆ ArgumentQueuesSize

size_t mtsInterfaceRequired::ArgumentQueuesSize
protected

Size to be used for argument queues

◆ ConnectionID

ConnectionIDType mtsInterfaceRequired::ConnectionID
protected

Connection ID assigned by manager component. This is not really needed, but is maintained for historical reasons.

◆ EventHandlersVoid

EventHandlerVoidMapType mtsInterfaceRequired::EventHandlersVoid
protected

◆ EventHandlersWrite

EventHandlerWriteMapType mtsInterfaceRequired::EventHandlersWrite
protected

◆ EventReceiversVoid

EventReceiverVoidMapType mtsInterfaceRequired::EventReceiversVoid
protected

Typedef for a receiver of void events

◆ EventReceiversWrite

EventReceiverWriteMapType mtsInterfaceRequired::EventReceiversWrite
protected

Typedef for a receiver of write events

◆ FunctionsQualifiedRead

FunctionInfoMapType mtsInterfaceRequired::FunctionsQualifiedRead
protected

Typedef for a map of name of two argument command and name of command.

◆ FunctionsRead

FunctionInfoMapType mtsInterfaceRequired::FunctionsRead
protected

Typedef for a map of name of one argument command and name of command.

◆ FunctionsVoid

FunctionInfoMapType mtsInterfaceRequired::FunctionsVoid
protected

Typedef for a map of name of zero argument command and name of command.

◆ FunctionsVoidReturn

FunctionInfoMapType mtsInterfaceRequired::FunctionsVoidReturn
protected

Typedef for a map of name of zero argument command and name of command.

◆ FunctionsWrite

FunctionInfoMapType mtsInterfaceRequired::FunctionsWrite
protected

Typedef for a map of name of one argument command and name of command.

◆ FunctionsWriteReturn

FunctionInfoMapType mtsInterfaceRequired::FunctionsWriteReturn
protected

Typedef for a map of name of one argument command and name of command.

◆ InterfaceProvided

const mtsInterfaceProvided* mtsInterfaceRequired::InterfaceProvided
protected

Pointer to provided interface that we are connected to.

◆ MailBox

mtsMailBox* mtsInterfaceRequired::MailBox
protected

Mailbox (if supported).

◆ MailBoxSize

size_t mtsInterfaceRequired::MailBoxSize
protected

Size to be used for mailboxes

◆ Required

mtsRequiredType mtsInterfaceRequired::Required
protected

Indicates if the interface must be connected.

◆ ThreadSignalForBlockingCommands

osaThreadSignal mtsInterfaceRequired::ThreadSignalForBlockingCommands
protected

Thread signal used for blocking calls. It is shared between all functions

The documentation for this class was generated from the following file:
Generated by doxygen 1.18.0