#include <mtsInterfaceProvided.h>

Inheritance diagram for mtsInterfaceProvided:

Public Types
enum	{ DEFAULT_MAIL_BOX_AND_ARGUMENT_QUEUES_SIZE = 64 }
typedef mtsInterfaceProvided	ThisType
typedef mtsInterface	BaseType
typedef cmnNamedMap< mtsCommandVoid >	CommandVoidMapType
typedef cmnNamedMap< mtsCommandVoidReturn >	CommandVoidReturnMapType
typedef cmnNamedMap< mtsCommandWriteBase >	CommandWriteMapType
typedef cmnNamedMap< mtsCommandWriteReturn >	CommandWriteReturnMapType
typedef cmnNamedMap< mtsCommandRead >	CommandReadMapType
typedef cmnNamedMap< mtsCommandQualifiedRead >	CommandQualifiedReadMapType
typedef cmnNamedMap< mtsMulticastCommandVoid >	EventVoidMapType
typedef cmnNamedMap< mtsMulticastCommandWriteBase >	EventWriteMapType
typedef cmnNamedMap< mtsCommandBase >	CommandInternalMapType

Public Member Functions
	mtsInterfaceProvided (const std::string &name, mtsComponent component, mtsInterfaceQueueingPolicy queueingPolicy, mtsCallableVoidBase postCommandQueuedCallable=0)
virtual	~mtsInterfaceProvided ()
void	Cleanup (void)
void	SetMailBoxSize (size_t desiredSize)
size_t	GetMailBoxSize (void) const
void	SetArgumentQueuesSize (size_t desiredSize)
size_t	GetArgumentQueuesSize (void) const
void	SetMailBoxAndArgumentQueuesSize (size_t desiredSize)
mtsInterfaceProvidedDescription	GetDescription () const
std::vector< std::string >	GetNamesOfCommands (void) const
std::vector< std::string >	GetNamesOfCommandsVoid (void) const
std::vector< std::string >	GetNamesOfCommandsVoidReturn (void) const
std::vector< std::string >	GetNamesOfCommandsWrite (void) const
std::vector< std::string >	GetNamesOfCommandsWriteReturn (void) const
std::vector< std::string >	GetNamesOfCommandsRead (void) const
std::vector< std::string >	GetNamesOfCommandsQualifiedRead (void) const
std::vector< std::string >	GetNamesOfEventsVoid (void) const
std::vector< std::string >	GetNamesOfEventsWrite (void) const
mtsCommandVoid *	GetCommandVoid (const std::string &commandName, const mtsRequiredType required=MTS_REQUIRED) const
mtsCommandVoidReturn *	GetCommandVoidReturn (const std::string &commandName, const mtsRequiredType required=MTS_REQUIRED) const
mtsCommandWriteBase *	GetCommandWrite (const std::string &commandName, const mtsRequiredType required=MTS_REQUIRED) const
mtsCommandWriteReturn *	GetCommandWriteReturn (const std::string &commandName, const mtsRequiredType required=MTS_REQUIRED) const
mtsCommandRead *	GetCommandRead (const std::string &commandName, const mtsRequiredType required=MTS_REQUIRED) const
mtsCommandQualifiedRead *	GetCommandQualifiedRead (const std::string &commandName, const mtsRequiredType required=MTS_REQUIRED) const
const cmnClassServicesBase *	GetCommandWriteArgumentServices (const std::string &commandName) const
const cmnClassServicesBase *	GetCommandReadArgumentServices (const std::string &commandName) const
mtsMulticastCommandVoid *	GetEventVoid (const std::string &eventName) const
mtsMulticastCommandWriteBase *	GetEventWrite (const std::string &eventName) const
template<class __classType>
mtsCommandVoid *	AddCommandVoid (void(__classType::method)(void), __classType classInstantiation, const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandVoid *	AddCommandVoid (void(*function)(void), const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __resultType>
mtsCommandVoidReturn *	AddCommandVoidReturn (void(__classType::method)(__resultType &), __classType classInstantiation, const std::string &commandName, const __resultType &resultPrototype, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __resultType>
mtsCommandVoidReturn *	AddCommandVoidReturn (void(__classType::method)(__resultType &), __classType classInstantiation, const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argumentType>
mtsCommandWriteBase *	AddCommandWrite (void(__classType::method)(const __argumentType &), __classType classInstantiation, const std::string &commandName, const __argumentType &argumentPrototype, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argumentType>
mtsCommandWriteBase *	AddCommandWrite (void(__classType::method)(const __argumentType &), __classType classInstantiation, const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argumentType, class __resultType>
mtsCommandWriteReturn *	AddCommandWriteReturn (void(__classType::method)(const __argumentType &, __resultType &), __classType classInstantiation, const std::string &commandName, const __argumentType &argumentPrototype, const __resultType &resultPrototype, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argumentType, class __resultType>
mtsCommandWriteReturn *	AddCommandWriteReturn (void(__classType::method)(const __argumentType &, __resultType &), __classType classInstantiation, const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argumentType>
mtsCommandRead *	AddCommandRead (void(__classType::method)(__argumentType &) const, __classType classInstantiation, const std::string &commandName, const __argumentType &argumentPrototype)
template<class __classType, class __argumentType>
mtsCommandRead *	AddCommandRead (void(__classType::method)(__argumentType &) const, __classType classInstantiation, const std::string &commandName)
template<class _elementType>
mtsCommandRead *	AddCommandReadState (const mtsStateTable &stateTable, const _elementType &stateData, const std::string &commandName)
template<class _elementType, class _outputType>
mtsCommandRead *	AddCommandFilteredReadState (const mtsStateTable &stateTable, const _elementType &stateData, bool(_elementType::*getMethod)(_outputType &) const, const std::string &commandName)
template<class _elementType, class _outputType>
mtsCommandRead *	AddCommandFilteredReadState (const mtsStateTable &stateTable, const _elementType &stateData, _outputType(_elementType::*getMethod)(void) const, const std::string &commandName)
template<class _elementType, class _outputType>
mtsCommandRead *	AddCommandFilteredReadState (const mtsStateTable &stateTable, const _elementType &stateData, bool(*convertFunction)(const _elementType &input, _outputType &output), const std::string &commandName)
template<class _elementType>
mtsCommandRead *	AddCommandReadStateDelayed (const mtsStateTable &stateTable, const _elementType &stateData, const std::string &commandName)
template<class _elementType>
mtsCommandWriteBase *	AddCommandWriteState (const mtsStateTable &stateTable, const _elementType &stateData, const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argument1Type, class __argument2Type>
mtsCommandQualifiedRead *	AddCommandQualifiedRead (void(__classType::method)(const __argument1Type &, __argument2Type &) const, __classType classInstantiation, const std::string &commandName, const __argument1Type &argument1Prototype, const __argument2Type &argument2Prototype)
template<class __classType, class __argument1Type, class __argument2Type>
mtsCommandQualifiedRead *	AddCommandQualifiedRead (void(__classType::method)(const __argument1Type &, __argument2Type &) const, __classType classInstantiation, const std::string &commandName)
template<class __classType, class __argumentType, class __filteredType>
mtsCommandWriteBase *	AddCommandFilteredWrite (void(__classType::premethod)(const __argumentType &, __filteredType &) const, void(__classType::method)(const __filteredType &), __classType *classInstantiation, const std::string &commandName, const __argumentType &argumentPrototype, const __filteredType &filteredPrototype, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
template<class __classType, class __argumentType, class __filteredType>
mtsCommandWriteBase *	AddCommandFilteredWrite (void(__classType::premethod)(const __argumentType &, __filteredType &) const, void(__classType::method)(const __filteredType &), __classType *classInstantiation, const std::string &commandName, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandVoid *	AddEventVoid (const std::string &eventName)
bool	AddEventVoid (mtsFunctionVoid &eventTrigger, const std::string &eventName)
template<class __argumentType>
mtsCommandWriteBase *	AddEventWrite (const std::string &eventName, const __argumentType &argumentPrototype)
template<class __argumentType>
bool	AddEventWrite (mtsFunctionWrite &eventTrigger, const std::string &eventName, const __argumentType &argumentPrototype)
mtsCommandWriteBase *	AddEventWriteGeneric (const std::string &eventName, const mtsGenericObject &argumentPrototype)
bool	AddEventWriteGeneric (mtsFunctionWrite &eventTrigger, const std::string &eventName, const mtsGenericObject &argumentPrototype)
bool	AddObserver (const std::string &eventName, mtsCommandVoid *handler, const mtsRequiredType required=MTS_REQUIRED)
bool	AddObserver (const std::string &eventName, mtsCommandWriteBase *handler, const mtsRequiredType required=MTS_REQUIRED)
void	AddObserverList (const mtsEventHandlerList &argin, mtsEventHandlerList &argout)
bool	RemoveObserver (const std::string &eventName, mtsCommandVoid *handler)
bool	RemoveObserver (const std::string &eventName, mtsCommandWriteBase *handler)
void	RemoveObserverList (const mtsEventHandlerList &argin, mtsEventHandlerList &argout)
void	AddMessageEvents (void)
void	SendStatus (const std::string &message)
void	SendWarning (const std::string &message)
void	SendError (const std::string &message)
mtsInterfaceProvided *	GetOriginalInterface (void) const
mtsInterfaceProvided *	FindEndUserInterfaceByName (const std::string &userName)
std::vector< std::string >	GetListOfUserNames (void) const
int	GetNumberOfEndUsers () const
size_t	ProcessMailBoxes (void)
void	ToStream (std::ostream &outputStream) const override
mtsInterfaceProvided *	GetEndUserInterface (const std::string &userName)
template<class _elementType, class _outputType, class _filterMethod>
mtsCommandRead *	AddCommandFilteredReadStateInternal (const mtsStateTable &stateTable, const _elementType &stateData, _filterMethod filterMethod, const std::string &commandName)
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

Static Public Member Functions
static bool	IsSystemEventVoid (const std::string &name)

Protected Types
typedef std::pair< size_t, ThisType * >	InterfaceProvidedCreatedPairType
typedef std::list< InterfaceProvidedCreatedPairType >	InterfaceProvidedCreatedListType

Protected Member Functions
	mtsInterfaceProvided (mtsInterfaceProvided *interfaceProvided, const std::string &userName, size_t mailBoxSize, size_t argumentQueuesSize)
mtsInterfaceProvided *	RemoveEndUserInterface (mtsInterfaceProvided *interfaceProvided, const std::string &userName)
template<class _MapType, class _QueuedType>
void	CloneCommands (const std::string &cmdType, const _MapType &CommandMapIn, _MapType &CommandMapOut)
bool	UseQueueBasedOnInterfacePolicy (mtsCommandQueueingPolicy queueingPolicy, const std::string &methodName, const std::string &commandName)
mtsMailBox *	GetMailBox (void)
mtsCommandVoid *	AddCommandVoid (mtsCallableVoidBase *callable, const std::string &name, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandVoidReturn *	AddCommandVoidReturn (mtsCallableVoidReturnBase callable, const std::string &name, const mtsGenericObject resultPrototype, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandWriteBase *	AddCommandWrite (mtsCommandWriteBase *command, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandWriteReturn *	AddCommandWriteReturn (mtsCallableWriteReturnBase callable, const std::string &name, const mtsGenericObject argumentPrototype, const mtsGenericObject *resultPrototype, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandWriteBase *	AddCommandFilteredWrite (mtsCommandQualifiedRead filter, mtsCommandWriteBase command, mtsCommandQueueingPolicy queueingPolicy=MTS_INTERFACE_COMMAND_POLICY)
mtsCommandRead *	AddCommandRead (mtsCallableReadBase callable, const std::string &name, const mtsGenericObject argumentPrototype)
mtsCommandQualifiedRead *	AddCommandQualifiedRead (mtsCallableQualifiedReadBase callable, const std::string &name, const mtsGenericObject argument1Prototype, const mtsGenericObject *argument2Prototype)
mtsCommandVoid *	AddCommandVoid (mtsCommandVoid *command)
mtsCommandVoidReturn *	AddCommandVoidReturn (mtsCommandVoidReturn *command)
mtsCommandWriteReturn *	AddCommandWriteReturn (mtsCommandWriteReturn *command)
mtsCommandRead *	AddCommandRead (mtsCommandRead *command)
mtsCommandQualifiedRead *	AddCommandQualifiedRead (mtsCommandQualifiedRead *command)
template<class _elementType, class _outputType, class _filterType>
mtsCommandRead *	AddCommandFilteredReadStateInternal (const mtsStateTable &stateTable, const _elementType &stateData, _filterType filterMethod, const std::string &commandName)
bool	AddEvent (const std::string &commandName, mtsMulticastCommandVoid *generator)
bool	AddEvent (const std::string &commandName, mtsMulticastCommandWriteBase *generator)
bool	AddSystemEvents (void)
bool	GetDescription (mtsInterfaceProvidedDescription &providedInterfaceDescription) const
Protected Member Functions inherited from mtsInterface
void	Initialize (void)

Static Protected Member Functions
static std::string	GenerateEndUserInterfaceName (const mtsInterfaceProvided *originalInterface, const std::string &userName)

Protected Attributes
InterfaceProvidedCreatedListType	InterfacesProvidedCreated
mtsMailBox *	MailBox
mtsInterfaceQueueingPolicy	QueueingPolicy
size_t	MailBoxSize
size_t	ArgumentQueuesSize
mtsCommandVoid *	BlockingCommandExecuted
mtsCommandVoid *	BlockingCommandReturnExecuted
ThisType *	OriginalInterface
bool	EndUserInterface
std::string	UserName
size_t	UserCounter
CommandVoidMapType	CommandsVoid
CommandVoidReturnMapType	CommandsVoidReturn
CommandWriteMapType	CommandsWrite
CommandWriteReturnMapType	CommandsWriteReturn
CommandReadMapType	CommandsRead
CommandQualifiedReadMapType	CommandsQualifiedRead
EventVoidMapType	EventVoidGenerators
EventWriteMapType	EventWriteGenerators
CommandInternalMapType	CommandsInternal
std::vector< mtsStateTableFilterBase * >	StateTableFilters
mtsCallableVoidBase *	PostCommandQueuedCallable
struct mtsInterfaceProvided:: { ... }	mMessages
Protected Attributes inherited from mtsInterface
const std::string	Name
mtsComponent *	Component
std::set< std::string >	mTags

Friends
class	mtsManagerLocal
class	mtsComponent
class	mtsManagerComponent
class	mtsComponentAddLatency
class	mtsSocketProxyClient
class	mtsSocketProxyServer
class	mtsManagerLocalTest

Detailed Description

This class implements the provided interface for a component, mtsComponent. It provides services via 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 interface can also generate two types of events:

Void: no parameters Write: one const parameter

Clients (components) connect to this interface and obtain pointers to command objects. They can then execute these command objects to obtain the desired service. Clients can also provide event handlers to the interface – these are actually command objects that the device will execute when the particular event occurs (Observer Pattern).

This class includes both public and protected members functions. The public members are for access by connected clients. The protected members are for access by the owning device, in order to populate the lists of commands and events.

Note that this class is instantiated by both mtsComponent and its derived mtsTask classes, via the virtual method AddInterfaceProvided. Because mtsTask (and its derived classes) have a thread, they (by default) instantiate mtsInterfaceProvided with a queueing policy of MTS_COMMANDS_SHOULD_BE_QUEUED. In this case, the provided interface uses queues for Void and Write commands in order to maintain thread safety. Furthermore, a separate queue is allocated for each client that connects to this interface – this ensures that each queue has only a single writer (the client) and a single reader (this task), so thread-safety can be achieved without relying on potentially blocking mutexes. This is implemented by the GetEndUserInterface method, which returns a new mtsInterfaceProvided object to the client component. In other words, the original provided interface acts as a provided interface factory that generates a "copy" of the provided interface for every client. Note that GetEndUserInterface is protected, and should only be called by mtsComponent.

Member Typedef Documentation

◆ BaseType

typedef mtsInterface mtsInterfaceProvided::BaseType

Base class

◆ CommandInternalMapType

typedef cmnNamedMap<mtsCommandBase> mtsInterfaceProvided::CommandInternalMapType

Typedef for a map of internally-generated commands (only used for garbage collection).

◆ CommandQualifiedReadMapType

typedef cmnNamedMap<mtsCommandQualifiedRead> mtsInterfaceProvided::CommandQualifiedReadMapType

Typedef for a map of name and qualified read commands.

◆ CommandReadMapType

typedef cmnNamedMap<mtsCommandRead> mtsInterfaceProvided::CommandReadMapType

Typedef for a map of name and read commands.

◆ CommandVoidMapType

typedef cmnNamedMap<mtsCommandVoid> mtsInterfaceProvided::CommandVoidMapType

Typedef for a map of name and void commands.

◆ CommandVoidReturnMapType

typedef cmnNamedMap<mtsCommandVoidReturn> mtsInterfaceProvided::CommandVoidReturnMapType

Typedef for a map of name and void return commands.

◆ CommandWriteMapType

typedef cmnNamedMap<mtsCommandWriteBase> mtsInterfaceProvided::CommandWriteMapType

Typedef for a map of name and write commands.

◆ CommandWriteReturnMapType

typedef cmnNamedMap<mtsCommandWriteReturn> mtsInterfaceProvided::CommandWriteReturnMapType

Typedef for a map of name and write return commands.

◆ EventVoidMapType

typedef cmnNamedMap<mtsMulticastCommandVoid> mtsInterfaceProvided::EventVoidMapType

Typedef for a map of event name and void event generators.

◆ EventWriteMapType

typedef cmnNamedMap<mtsMulticastCommandWriteBase> mtsInterfaceProvided::EventWriteMapType

Typedef for a map of event name and write event generators.

◆ InterfaceProvidedCreatedListType

typedef std::list<InterfaceProvidedCreatedPairType> mtsInterfaceProvided::InterfaceProvidedCreatedListType

protected

◆ InterfaceProvidedCreatedPairType

typedef std::pair<size_t, ThisType *> mtsInterfaceProvided::InterfaceProvidedCreatedPairType

protected

types and containers to store interfaces cloned for thread safety

◆ ThisType

typedef mtsInterfaceProvided mtsInterfaceProvided::ThisType

This type

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Default size for mail boxes and argument queues

Enumerator
DEFAULT_MAIL_BOX_AND_ARGUMENT_QUEUES_SIZE

Constructor & Destructor Documentation

◆ mtsInterfaceProvided() [1/2]

mtsInterfaceProvided::mtsInterfaceProvided	(	const std::string &	name,
		mtsComponent *	component,
		mtsInterfaceQueueingPolicy	queueingPolicy,
		mtsCallableVoidBase *	postCommandQueuedCallable = 0 )

Constructor with a post queued command. This constructor is used by mtsTaskFromSignal to provide the command used everytime one uses a queued command of this interface (write and void commands). The post command queued command in this case performs a wakeup (signal) on the task's thread.

◆ ~mtsInterfaceProvided()

virtual mtsInterfaceProvided::~mtsInterfaceProvided ( )

virtual

Default Destructor.

◆ mtsInterfaceProvided() [2/2]

mtsInterfaceProvided::mtsInterfaceProvided	(	mtsInterfaceProvided *	interfaceProvided,
		const std::string &	userName,
		size_t	mailBoxSize,
		size_t	argumentQueuesSize )

protected

Constructor used to create an end user interface (object factory) for each user (interface required). This constructor is called by the method GetEndUserInterface.

Member Function Documentation

◆ AddCommandFilteredReadState() [1/3]

template<class _elementType, class _outputType>

mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadState	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		_outputType(_elementType::*	getMethod )(void) const,
		const std::string &	commandName )

◆ AddCommandFilteredReadState() [2/3]

template<class _elementType, class _outputType>

mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadState	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		bool(*	convertFunction )(const _elementType &input, _outputType &output),
		const std::string &	commandName )

◆ AddCommandFilteredReadState() [3/3]

template<class _elementType, class _outputType>

mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadState	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		bool(_elementType::*	getMethod )(_outputType &) const,
		const std::string &	commandName )

◆ AddCommandFilteredReadStateInternal() [1/2]

template<class _elementType, class _outputType, class _filterMethod>

mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadStateInternal	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		_filterMethod	filterMethod,
		const std::string &	commandName )

◆ AddCommandFilteredReadStateInternal() [2/2]

template<class _elementType, class _outputType, class _filterType>

mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadStateInternal	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		_filterType	filterMethod,
		const std::string &	commandName )

protected

Internal method to avoid code duplication in AddCommandFilteredReadState

◆ AddCommandFilteredWrite() [1/3]

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandFilteredWrite	(	mtsCommandQualifiedRead *	filter,
		mtsCommandWriteBase *	command,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

protected

◆ AddCommandFilteredWrite() [2/3]

template<class __classType, class __argumentType, class __filteredType>

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandFilteredWrite	(	void(__classType::*	premethod )(const __argumentType &, __filteredType &) const,
		void(__classType::*	method )(const __filteredType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		const __argumentType &	argumentPrototype,
		const __filteredType &	filteredPrototype,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

◆ AddCommandFilteredWrite() [3/3]

template<class __classType, class __argumentType, class __filteredType>

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandFilteredWrite	(	void(__classType::*	premethod )(const __argumentType &, __filteredType &) const,
		void(__classType::*	method )(const __filteredType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

◆ AddCommandQualifiedRead() [1/4]

mtsCommandQualifiedRead * mtsInterfaceProvided::AddCommandQualifiedRead	(	mtsCallableQualifiedReadBase *	callable,
		const std::string &	name,
		const mtsGenericObject *	argument1Prototype,
		const mtsGenericObject *	argument2Prototype )

protected

◆ AddCommandQualifiedRead() [2/4]

mtsCommandQualifiedRead * mtsInterfaceProvided::AddCommandQualifiedRead ( mtsCommandQualifiedRead * command )

protected

◆ AddCommandQualifiedRead() [3/4]

template<class __classType, class __argument1Type, class __argument2Type>

mtsCommandQualifiedRead * mtsInterfaceProvided::AddCommandQualifiedRead	(	void(__classType::*	method )(const __argument1Type &, __argument2Type &) const,
		__classType *	classInstantiation,
		const std::string &	commandName )

inline

◆ AddCommandQualifiedRead() [4/4]

template<class __classType, class __argument1Type, class __argument2Type>

mtsCommandQualifiedRead * mtsInterfaceProvided::AddCommandQualifiedRead	(	void(__classType::*	method )(const __argument1Type &, __argument2Type &) const,
		__classType *	classInstantiation,
		const std::string &	commandName,
		const __argument1Type &	argument1Prototype,
		const __argument2Type &	argument2Prototype )

inline

◆ AddCommandRead() [1/4]

mtsCommandRead * mtsInterfaceProvided::AddCommandRead	(	mtsCallableReadBase *	callable,
		const std::string &	name,
		const mtsGenericObject *	argumentPrototype )

protected

◆ AddCommandRead() [2/4]

mtsCommandRead * mtsInterfaceProvided::AddCommandRead ( mtsCommandRead * command )

protected

◆ AddCommandRead() [3/4]

template<class __classType, class __argumentType>

mtsCommandRead * mtsInterfaceProvided::AddCommandRead	(	void(__classType::*	method )(__argumentType &) const,
		__classType *	classInstantiation,
		const std::string &	commandName )

inline

◆ AddCommandRead() [4/4]

template<class __classType, class __argumentType>

mtsCommandRead * mtsInterfaceProvided::AddCommandRead	(	void(__classType::*	method )(__argumentType &) const,
		__classType *	classInstantiation,
		const std::string &	commandName,
		const __argumentType &	argumentPrototype )

inline

Add a read command to the provided interface based on a method and an object instantiating the method. This method creates an mtsCommandRead object and then calls the AddCommandRead virtual method.

Parameters

method	method pointer
classInstantiation	an instantiation of the method's class
commandName	name as it should appear in the interface
argumentPrototype	example of argument that should be used to call this method. This is especially useful for commands using objects of variable size (dynamic allocation)

Returns: pointer on the newly created and added command, null pointer (0) if creation or addition failed (name already used)

◆ AddCommandReadState()

template<class _elementType>

mtsCommandRead * mtsInterfaceProvided::AddCommandReadState	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		const std::string &	commandName )

Adds command objects to read from the state table (by default, all tasks have state tables, but it is possible to have a state table in a device). Note that there are two command objects: a 'read' command to get the latest value, and a 'qualified read' command to get the value at the specified time.

◆ AddCommandReadStateDelayed()

template<class _elementType>

mtsCommandRead * mtsInterfaceProvided::AddCommandReadStateDelayed	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		const std::string &	commandName )

Adds command objects to read from the state table with a delay. The commands created ('read' and 'qualified read') are similar to the commands added using AddCommandReadState except that instead of reading from the head, these commands read from head - delay.

◆ AddCommandVoid() [1/4]

mtsCommandVoid * mtsInterfaceProvided::AddCommandVoid	(	mtsCallableVoidBase *	callable,
		const std::string &	name,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

protected

◆ AddCommandVoid() [2/4]

mtsCommandVoid * mtsInterfaceProvided::AddCommandVoid ( mtsCommandVoid * command )

protected

Methods to add an existing command to the interface. These methods will not check the queueing policy of the interface nor the type of command (queued or not). These methods must be used with extreme caution since they bypass the built-in thread safety mechanisms.

◆ AddCommandVoid() [3/4]

mtsCommandVoid * mtsInterfaceProvided::AddCommandVoid	(	void(*	function )(void),
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

Add a void command to the provided interface based on a void function. This method creates an mtsCommandVoid object and then calls the AddCommandVoid virtual method; this method is overridden in mtsInterfaceProvided to queue the void command (thereby ensuring thread safety).

Parameters

function	void function pointer
commandName	name as it should appear in the interface

Returns: pointer on the newly created and added command, null pointer (0) if creation or addition failed (name already used)

◆ AddCommandVoid() [4/4]

template<class __classType>

mtsCommandVoid * mtsInterfaceProvided::AddCommandVoid	(	void(__classType::*	method )(void),
		__classType *	classInstantiation,
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

Add a void command to the provided interface based on a method and an object instantiating the method. This method creates an mtsCommandVoid object and then calls the AddCommandVoid virtual method; this method is overridden in mtsInterfaceProvided to queue the void command (thereby ensuring thread safety).

Parameters

method	method pointer
classInstantiation	an instantiation of the method's class
commandName	name as it should appear in the interface

Returns: pointer on the newly created and added command, null pointer (0) if creation or addition failed (name already used)

◆ AddCommandVoidReturn() [1/4]

mtsCommandVoidReturn * mtsInterfaceProvided::AddCommandVoidReturn	(	mtsCallableVoidReturnBase *	callable,
		const std::string &	name,
		const mtsGenericObject *	resultPrototype,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

protected

◆ AddCommandVoidReturn() [2/4]

mtsCommandVoidReturn * mtsInterfaceProvided::AddCommandVoidReturn ( mtsCommandVoidReturn * command )

protected

◆ AddCommandVoidReturn() [3/4]

template<class __classType, class __resultType>

mtsCommandVoidReturn * mtsInterfaceProvided::AddCommandVoidReturn	(	void(__classType::*	method )(__resultType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		const __resultType &	resultPrototype,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

Add a void command with result.

◆ AddCommandVoidReturn() [4/4]

template<class __classType, class __resultType>

mtsCommandVoidReturn * mtsInterfaceProvided::AddCommandVoidReturn	(	void(__classType::*	method )(__resultType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

◆ AddCommandWrite() [1/3]

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandWrite	(	mtsCommandWriteBase *	command,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

protected

◆ AddCommandWrite() [2/3]

template<class __classType, class __argumentType>

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandWrite	(	void(__classType::*	method )(const __argumentType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		const __argumentType &	argumentPrototype,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

Add a write command to the provided interface based on a method and an object instantiating the method. This method creates an mtsCommandWrite object and then calls the AddCommandWrite virtual method; this method is overridden in mtsInterfaceProvided to queue the write command (thereby ensuring thread safety).

Parameters

method	method pointer
classInstantiation	an instantiation of the method's class
commandName	name as it should appear in the interface
argumentPrototype	example of argument that should be used to call this method. This is especially useful for commands using objects of variable size (dynamic allocation)

Returns: pointer on the newly created and added command, null pointer (0) if creation or addition failed (name already used)

◆ AddCommandWrite() [3/3]

template<class __classType, class __argumentType>

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandWrite	(	void(__classType::*	method )(const __argumentType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

◆ AddCommandWriteReturn() [1/4]

mtsCommandWriteReturn * mtsInterfaceProvided::AddCommandWriteReturn	(	mtsCallableWriteReturnBase *	callable,
		const std::string &	name,
		const mtsGenericObject *	argumentPrototype,
		const mtsGenericObject *	resultPrototype,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

protected

◆ AddCommandWriteReturn() [2/4]

mtsCommandWriteReturn * mtsInterfaceProvided::AddCommandWriteReturn ( mtsCommandWriteReturn * command )

protected

◆ AddCommandWriteReturn() [3/4]

template<class __classType, class __argumentType, class __resultType>

mtsCommandWriteReturn * mtsInterfaceProvided::AddCommandWriteReturn	(	void(__classType::*	method )(const __argumentType &, __resultType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		const __argumentType &	argumentPrototype,
		const __resultType &	resultPrototype,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

Add a write command with result.

◆ AddCommandWriteReturn() [4/4]

template<class __classType, class __argumentType, class __resultType>

mtsCommandWriteReturn * mtsInterfaceProvided::AddCommandWriteReturn	(	void(__classType::*	method )(const __argumentType &, __resultType &),
		__classType *	classInstantiation,
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

inline

◆ AddCommandWriteState()

template<class _elementType>

mtsCommandWriteBase * mtsInterfaceProvided::AddCommandWriteState	(	const mtsStateTable &	stateTable,
		const _elementType &	stateData,
		const std::string &	commandName,
		mtsCommandQueueingPolicy	queueingPolicy = MTS_INTERFACE_COMMAND_POLICY )

Adds command object to write to state table.

◆ AddEvent() [1/2]

bool mtsInterfaceProvided::AddEvent	(	const std::string &	commandName,
		mtsMulticastCommandVoid *	generator )

protected

◆ AddEvent() [2/2]

bool mtsInterfaceProvided::AddEvent	(	const std::string &	commandName,
		mtsMulticastCommandWriteBase *	generator )

protected

◆ AddEventVoid() [1/2]

mtsCommandVoid * mtsInterfaceProvided::AddEventVoid ( const std::string & eventName )

Add events to the interface. This method creates the multicast command used to trigger all the observers for the event. These methods are used to populate the provided interface.

◆ AddEventVoid() [2/2]

bool mtsInterfaceProvided::AddEventVoid	(	mtsFunctionVoid &	eventTrigger,
		const std::string &	eventName )

◆ AddEventWrite() [1/2]

template<class __argumentType>

mtsCommandWriteBase * mtsInterfaceProvided::AddEventWrite	(	const std::string &	eventName,
		const __argumentType &	argumentPrototype )

◆ AddEventWrite() [2/2]

template<class __argumentType>

bool mtsInterfaceProvided::AddEventWrite	(	mtsFunctionWrite &	eventTrigger,
		const std::string &	eventName,
		const __argumentType &	argumentPrototype )

◆ AddEventWriteGeneric() [1/2]

mtsCommandWriteBase * mtsInterfaceProvided::AddEventWriteGeneric	(	const std::string &	eventName,
		const mtsGenericObject &	argumentPrototype )

◆ AddEventWriteGeneric() [2/2]

bool mtsInterfaceProvided::AddEventWriteGeneric	(	mtsFunctionWrite &	eventTrigger,
		const std::string &	eventName,
		const mtsGenericObject &	argumentPrototype )

◆ AddMessageEvents()

void mtsInterfaceProvided::AddMessageEvents ( void )

Human readable messages. This method adds 3 events to the provided interface: Status, Warning and Error. Each of them uses the payload mtsMessage which contains a string, a timestamp and a counter. The event triggers are protected, users can only call the methods SendStatus, SendWarning and SendError with a user message. These methods will maintain the event counter, timestamp the messages, log using cmnLogger and finally emit the message event.

◆ AddObserver() [1/2]

bool mtsInterfaceProvided::AddObserver	(	const std::string &	eventName,
		mtsCommandVoid *	handler,
		const mtsRequiredType	required = MTS_REQUIRED )

Add an observer for the specified event. These methods are used to connect to an existing provided interface, ideally from a required interface.

Parameters

name	Name of event
handler	command object that implements event handler

Returns: true if successful; false otherwise

◆ AddObserver() [2/2]

bool mtsInterfaceProvided::AddObserver	(	const std::string &	eventName,
		mtsCommandWriteBase *	handler,
		const mtsRequiredType	required = MTS_REQUIRED )

◆ AddObserverList()

void mtsInterfaceProvided::AddObserverList	(	const mtsEventHandlerList &	argin,
		mtsEventHandlerList &	argout )

◆ AddSystemEvents()

bool mtsInterfaceProvided::AddSystemEvents ( void )

protected

◆ Cleanup()

void mtsInterfaceProvided::Cleanup ( void )

The member function that is executed once the task terminates. This does some cleanup work

◆ CloneCommands()

template<class _MapType, class _QueuedType>

void mtsInterfaceProvided::CloneCommands	(	const std::string &	cmdType,
		const _MapType &	CommandMapIn,
		_MapType &	CommandMapOut )

protected

Templated utility method to clone commands

◆ FindEndUserInterfaceByName()

mtsInterfaceProvided * mtsInterfaceProvided::FindEndUserInterfaceByName ( const std::string & userName )

Find an end-user interface given a client name.

◆ GenerateEndUserInterfaceName()

std::string mtsInterfaceProvided::GenerateEndUserInterfaceName	(	const mtsInterfaceProvided *	originalInterface,
		const std::string &	userName )

staticprotected

◆ GetArgumentQueuesSize()

size_t mtsInterfaceProvided::GetArgumentQueuesSize ( void ) const

inline

Get the current argument queues size.

◆ GetCommandQualifiedRead()

mtsCommandQualifiedRead * mtsInterfaceProvided::GetCommandQualifiedRead	(	const std::string &	commandName,
		const mtsRequiredType	required = MTS_REQUIRED ) const

◆ GetCommandRead()

mtsCommandRead * mtsInterfaceProvided::GetCommandRead	(	const std::string &	commandName,
		const mtsRequiredType	required = MTS_REQUIRED ) const

◆ GetCommandReadArgumentServices()

const cmnClassServicesBase * mtsInterfaceProvided::GetCommandReadArgumentServices ( const std::string & commandName ) const

◆ GetCommandVoid()

mtsCommandVoid * mtsInterfaceProvided::GetCommandVoid	(	const std::string &	commandName,
		const mtsRequiredType	required = MTS_REQUIRED ) const

Find a command based on its name.

◆ GetCommandVoidReturn()

mtsCommandVoidReturn * mtsInterfaceProvided::GetCommandVoidReturn	(	const std::string &	commandName,
		const mtsRequiredType	required = MTS_REQUIRED ) const

◆ GetCommandWrite()

mtsCommandWriteBase * mtsInterfaceProvided::GetCommandWrite	(	const std::string &	commandName,
		const mtsRequiredType	required = MTS_REQUIRED ) const

◆ GetCommandWriteArgumentServices()

const cmnClassServicesBase * mtsInterfaceProvided::GetCommandWriteArgumentServices ( const std::string & commandName ) const

Get argument class services for a command

◆ GetCommandWriteReturn()

mtsCommandWriteReturn * mtsInterfaceProvided::GetCommandWriteReturn	(	const std::string &	commandName,
		const mtsRequiredType	required = MTS_REQUIRED ) const

◆ GetDescription() [1/2]

mtsInterfaceProvidedDescription mtsInterfaceProvided::GetDescription ( ) const

Get the description of this interface.

◆ GetDescription() [2/2]

bool mtsInterfaceProvided::GetDescription ( mtsInterfaceProvidedDescription & providedInterfaceDescription ) const

protected

Get description of this interface (with serialized argument information)

◆ GetEndUserInterface()

mtsInterfaceProvided * mtsInterfaceProvided::GetEndUserInterface ( const std::string & userName )

This method creates a copy of the existing interface. The copy is required for each new user, i.e. for each required interface connected to this provided interface if queueing has been enabled. This method should not be called on a provided interface if queueing is not enable. The newly created provided interface is created using the current MailBoxSize (see SetMailBoxSize) and ArgumentQueuesSize (see SetArgumentQueuesSize). Commands and events should only be added to the original interface.

Parameters

userName name of the required interface being connected to this provided interface. This information is used for logging only.

Returns: pointer to end-user interface (0 if error)

◆ GetEventVoid()

mtsMulticastCommandVoid * mtsInterfaceProvided::GetEventVoid ( const std::string & eventName ) const

Find an event based on its name.

◆ GetEventWrite()

mtsMulticastCommandWriteBase * mtsInterfaceProvided::GetEventWrite ( const std::string & eventName ) const

◆ GetListOfUserNames()

std::vector< std::string > mtsInterfaceProvided::GetListOfUserNames ( void ) const

Returns a list of user names (name of connected required interface). Used to remove provided interface in a thread-safe way

◆ GetMailBox()

mtsMailBox * mtsInterfaceProvided::GetMailBox ( void )

protected

◆ GetMailBoxSize()

size_t mtsInterfaceProvided::GetMailBoxSize ( void ) const

inline

Get the current mailbox size.

◆ GetNamesOfCommands()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommands ( void ) const

Get the names of commands provided by this interface.

◆ GetNamesOfCommandsQualifiedRead()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommandsQualifiedRead ( void ) const

◆ GetNamesOfCommandsRead()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommandsRead ( void ) const

◆ GetNamesOfCommandsVoid()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommandsVoid ( void ) const

◆ GetNamesOfCommandsVoidReturn()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommandsVoidReturn ( void ) const

◆ GetNamesOfCommandsWrite()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommandsWrite ( void ) const

◆ GetNamesOfCommandsWriteReturn()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfCommandsWriteReturn ( void ) const

◆ GetNamesOfEventsVoid()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfEventsVoid ( void ) const

Get the names of events coming from this interface

◆ GetNamesOfEventsWrite()

std::vector< std::string > mtsInterfaceProvided::GetNamesOfEventsWrite ( void ) const

◆ GetNumberOfEndUsers()

int mtsInterfaceProvided::GetNumberOfEndUsers ( ) const

Return number of active end-user interfaces.

◆ GetOriginalInterface()

mtsInterfaceProvided * mtsInterfaceProvided::GetOriginalInterface ( void ) const

Get the original interface. This allows to retrieve the original interface from a copy created using GetEndUserInterface.

◆ IsSystemEventVoid()

bool mtsInterfaceProvided::IsSystemEventVoid ( const std::string & name )

static

Returns true if the event is a system event (e.g., BlockingCommandExecuted or BlockingCommandReturnExecuted)

◆ ProcessMailBoxes()

size_t mtsInterfaceProvided::ProcessMailBoxes ( void )

Method used to process all commands queued in mailboxes. This method should only be used by the component that owns the interface for thread safety.

◆ RemoveEndUserInterface()

mtsInterfaceProvided * mtsInterfaceProvided::RemoveEndUserInterface	(	mtsInterfaceProvided *	interfaceProvided,
		const std::string &	userName )

protected

This method deletes the end-user interface created by GetEndUserInterface. Note that there are two mtsInterfaceProvided objects: (1) the interfaceProvided parameter, which should be a pointer to the end-user interface to be removed (2) the "this" pointer, which should point to the original interface.

Parameters

interfaceProvided	the end-user interface to be removed
userName	name of the required interface (used for logging only)

Returns: 0 if successful, interfaceProvided otherwise

◆ RemoveObserver() [1/2]

bool mtsInterfaceProvided::RemoveObserver	(	const std::string &	eventName,
		mtsCommandVoid *	handler )

Remove an observer for the specified event. These methods are used when disconnecting from the provided interface.

Parameters

name	Name of event
handler	command object that implements event handler

Returns: true if successful; false otherwise

◆ RemoveObserver() [2/2]

bool mtsInterfaceProvided::RemoveObserver	(	const std::string &	eventName,
		mtsCommandWriteBase *	handler )

◆ RemoveObserverList()

void mtsInterfaceProvided::RemoveObserverList	(	const mtsEventHandlerList &	argin,
		mtsEventHandlerList &	argout )

◆ SendError()

void mtsInterfaceProvided::SendError ( const std::string & message )

◆ SendStatus()

void mtsInterfaceProvided::SendStatus ( const std::string & message )

◆ SendWarning()

void mtsInterfaceProvided::SendWarning ( const std::string & message )

◆ SetArgumentQueuesSize()

void mtsInterfaceProvided::SetArgumentQueuesSize ( size_t desiredSize )

Set the desired size for all argument queues. If queueing has been enabled for this interface, each write command (write or write with return) 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 command mail box as there can't be more arguments queued than commands. The reciprocal is not true as different commands can be queued. So, the argument queue size should be lesser or equal to the mail box size.

The size of argument queues can't be changed while being used (i.e. while any required interface is connected to the provided interface.

◆ SetMailBoxAndArgumentQueuesSize()

void mtsInterfaceProvided::SetMailBoxAndArgumentQueuesSize ( size_t desiredSize )

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

◆ SetMailBoxSize()

void mtsInterfaceProvided::SetMailBoxSize ( size_t desiredSize )

Set the desired size for the command mail box. If queueing has been enabled for this interface, a single mailbox is created for each connected required interface. All commands provided by this interface share a single mailbox but each write command (write and write with return) manages it's own queue for the command 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 any required interface is connected to the provided interface.

◆ ToStream()

void mtsInterfaceProvided::ToStream ( std::ostream & outputStream ) const

overridevirtual

Send a human readable description of the interface.

Reimplemented from cmnGenericObject.

◆ UseQueueBasedOnInterfacePolicy()

bool mtsInterfaceProvided::UseQueueBasedOnInterfacePolicy	(	mtsCommandQueueingPolicy	queueingPolicy,
		const std::string &	methodName,
		const std::string &	commandName )

protected

Utility method to determine if a command 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.

◆ mtsComponent

friend class mtsComponent

friend

◆ mtsComponentAddLatency

friend class mtsComponentAddLatency

friend

◆ mtsManagerComponent

friend class mtsManagerComponent

friend

◆ mtsManagerLocal

friend class mtsManagerLocal

friend

◆ mtsManagerLocalTest

friend class mtsManagerLocalTest

friend

◆ mtsSocketProxyClient

friend class mtsSocketProxyClient

friend

◆ mtsSocketProxyServer

friend class mtsSocketProxyServer

friend

Member Data Documentation

◆ ArgumentQueuesSize

size_t mtsInterfaceProvided::ArgumentQueuesSize

protected

Size to be used for argument queues

◆ BlockingCommandExecuted

mtsCommandVoid* mtsInterfaceProvided::BlockingCommandExecuted

protected

Command to trigger void event for blocking commands.

◆ BlockingCommandReturnExecuted

mtsCommandVoid* mtsInterfaceProvided::BlockingCommandReturnExecuted

protected

Command to trigger void event for blocking commands with a return value.

◆ CommandsInternal

CommandInternalMapType mtsInterfaceProvided::CommandsInternal

protected

◆ CommandsQualifiedRead

CommandQualifiedReadMapType mtsInterfaceProvided::CommandsQualifiedRead

protected

◆ CommandsRead

CommandReadMapType mtsInterfaceProvided::CommandsRead

protected

◆ CommandsVoid

CommandVoidMapType mtsInterfaceProvided::CommandsVoid

protected

Containers of commands

◆ CommandsVoidReturn

CommandVoidReturnMapType mtsInterfaceProvided::CommandsVoidReturn

protected

◆ CommandsWrite

CommandWriteMapType mtsInterfaceProvided::CommandsWrite

protected

◆ CommandsWriteReturn

CommandWriteReturnMapType mtsInterfaceProvided::CommandsWriteReturn

protected

◆ EndUserInterface

bool mtsInterfaceProvided::EndUserInterface

protected

Flag to indicate if this interface can be used directly or if it should be used as a factory to create a new interface. When the interface relies assumes queued commands, the first interface should be created as a factory or template. All users should use their own copy created using GetEndUserInterface().

◆ EventVoidGenerators

EventVoidMapType mtsInterfaceProvided::EventVoidGenerators

protected

◆ EventWriteGenerators

EventWriteMapType mtsInterfaceProvided::EventWriteGenerators

protected

◆ InterfacesProvidedCreated

InterfaceProvidedCreatedListType mtsInterfaceProvided::InterfacesProvidedCreated

protected

◆ MailBox

mtsMailBox* mtsInterfaceProvided::MailBox

protected

Mailbox (if supported). Mailboxes should only be provided for end user provided interfaces (if needed). Factory interfaces should not use the mailbox.

◆ MailBoxSize

size_t mtsInterfaceProvided::MailBoxSize

protected

Size to be used for mailboxes

◆ mMessages

struct { ... } mtsInterfaceProvided::mMessages

◆ OriginalInterface

ThisType* mtsInterfaceProvided::OriginalInterface

protected

If this interface was created using an existing one, keep a pointer on the original one.

◆ PostCommandQueuedCallable

mtsCallableVoidBase* mtsInterfaceProvided::PostCommandQueuedCallable

protected

Post command queued command

◆ QueueingPolicy

mtsInterfaceQueueingPolicy mtsInterfaceProvided::QueueingPolicy

protected

Flag to determine if by default void and write commands are queued.

◆ StateTableFilters

std::vector<mtsStateTableFilterBase *> mtsInterfaceProvided::StateTableFilters

protected

The vector contains pointers to the state table filter methods from which command objects are created.

◆ UserCounter

size_t mtsInterfaceProvided::UserCounter

protected

Counter for number of users, i.e. number or required interfaces connected to this provided interface. This number should remain consistent with the size of created interfaces list.

◆ UserName

std::string mtsInterfaceProvided::UserName

protected

Name of user for end user interface

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

tmp/cisst-saw/cisst/cisstMultiTask/mtsInterfaceProvided.h

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BaseType

◆ CommandInternalMapType

◆ CommandQualifiedReadMapType

◆ CommandReadMapType

◆ CommandVoidMapType

◆ CommandVoidReturnMapType

◆ CommandWriteMapType

◆ CommandWriteReturnMapType

◆ EventVoidMapType

◆ EventWriteMapType

◆ InterfaceProvidedCreatedListType

◆ InterfaceProvidedCreatedPairType

◆ ThisType

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ mtsInterfaceProvided() [1/2]

◆ ~mtsInterfaceProvided()

◆ mtsInterfaceProvided() [2/2]

Member Function Documentation

◆ AddCommandFilteredReadState() [1/3]

◆ AddCommandFilteredReadState() [2/3]

◆ AddCommandFilteredReadState() [3/3]

◆ AddCommandFilteredReadStateInternal() [1/2]

◆ AddCommandFilteredReadStateInternal() [2/2]

◆ AddCommandFilteredWrite() [1/3]

◆ AddCommandFilteredWrite() [2/3]

◆ AddCommandFilteredWrite() [3/3]

◆ AddCommandQualifiedRead() [1/4]

◆ AddCommandQualifiedRead() [2/4]

◆ AddCommandQualifiedRead() [3/4]

◆ AddCommandQualifiedRead() [4/4]

◆ AddCommandRead() [1/4]

◆ AddCommandRead() [2/4]

◆ AddCommandRead() [3/4]

◆ AddCommandRead() [4/4]

◆ AddCommandReadState()

◆ AddCommandReadStateDelayed()

◆ AddCommandVoid() [1/4]

◆ AddCommandVoid() [2/4]

◆ AddCommandVoid() [3/4]

◆ AddCommandVoid() [4/4]

◆ AddCommandVoidReturn() [1/4]

◆ AddCommandVoidReturn() [2/4]

◆ AddCommandVoidReturn() [3/4]

◆ AddCommandVoidReturn() [4/4]

◆ AddCommandWrite() [1/3]

◆ AddCommandWrite() [2/3]

◆ AddCommandWrite() [3/3]

◆ AddCommandWriteReturn() [1/4]

◆ AddCommandWriteReturn() [2/4]

◆ AddCommandWriteReturn() [3/4]

◆ AddCommandWriteReturn() [4/4]

◆ AddCommandWriteState()

◆ AddEvent() [1/2]

◆ AddEvent() [2/2]

◆ AddEventVoid() [1/2]

◆ AddEventVoid() [2/2]

◆ AddEventWrite() [1/2]

◆ AddEventWrite() [2/2]

◆ AddEventWriteGeneric() [1/2]

◆ AddEventWriteGeneric() [2/2]

◆ AddMessageEvents()

◆ AddObserver() [1/2]

◆ AddObserver() [2/2]

◆ AddObserverList()

◆ AddSystemEvents()

◆ Cleanup()

◆ CloneCommands()

◆ FindEndUserInterfaceByName()