mtsInterfaceProvided.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Ankur Kapoor, Peter Kazanzides, Anton Deguet
  Created on: 2004-04-30
 
  (C) Copyright 2004-2026 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 

 
#ifndef _mtsInterfaceProvided_h
#define _mtsInterfaceProvided_h
 
#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnNamedMap.h>
 
#include <cisstMultiTask/mtsMailBox.h>
#include <cisstMultiTask/mtsStateTable.h>
#include <cisstMultiTask/mtsStateTableFilter.h>
#include <cisstMultiTask/mtsCallableVoidMethod.h>
#include <cisstMultiTask/mtsCallableVoidFunction.h>
#include <cisstMultiTask/mtsCallableVoidReturnMethod.h>
#include <cisstMultiTask/mtsCallableWriteReturnMethod.h>
#include <cisstMultiTask/mtsCallableReadMethod.h>
#include <cisstMultiTask/mtsCallableReadReturnVoidMethod.h>
#include <cisstMultiTask/mtsCallableQualifiedReadMethod.h>
#include <cisstMultiTask/mtsCallableQualifiedReadReturnVoidMethod.h>
#include <cisstMultiTask/mtsCommandQualifiedRead.h>
#include <cisstMultiTask/mtsCommandWrite.h>
#include <cisstMultiTask/mtsMulticastCommandWrite.h>
#include <cisstMultiTask/mtsInterface.h>
#include <cisstMultiTask/mtsParameterTypes.h>
#include <cisstMultiTask/mtsForwardDeclarations.h>
 
// Always include last
#include <cisstMultiTask/mtsExport.h>
 

class CISST_EXPORT mtsInterfaceProvided: public mtsInterface {
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);
 
    // To get information about event generators in this interface
    friend class mtsManagerLocal;
    // To call GetEndUserInterface
    friend class mtsComponent;
    friend class mtsManagerComponent;
 
    // to allow adding command write generic ...
    friend class mtsComponentAddLatency;
    friend class mtsSocketProxyClient;
    friend class mtsSocketProxyServer;
    // for unit-testing
    friend class mtsManagerLocalTest;
 
 public:
    typedef mtsInterfaceProvided ThisType;

    typedef mtsInterface BaseType;

    enum {DEFAULT_MAIL_BOX_AND_ARGUMENT_QUEUES_SIZE = 64};

    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;

    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 { return MailBoxSize; }

    void SetArgumentQueuesSize(size_t desiredSize);

    size_t GetArgumentQueuesSize(void) const { return ArgumentQueuesSize; }

    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;

    static bool IsSystemEventVoid(const std::string & name);

    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;
 
#ifndef SWIG
    template <class __classType>
    inline mtsCommandVoid * AddCommandVoid(void (__classType::*method)(void),
                                           __classType * classInstantiation,
                                           const std::string & commandName,
                                           mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandVoid(new mtsCallableVoidMethod<__classType>(method, classInstantiation), commandName, queueingPolicy);
    }

    inline mtsCommandVoid * AddCommandVoid(void (*function)(void),
                                           const std::string & commandName,
                                           mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandVoid(new mtsCallableVoidFunction(function), commandName, queueingPolicy);
    }

    template <class __classType, class __resultType>
    inline mtsCommandVoidReturn * AddCommandVoidReturn(void (__classType::*method)(__resultType &),
                                                       __classType * classInstantiation,
                                                       const std::string & commandName,
                                                       const __resultType & resultPrototype,
                                                       mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandVoidReturn(new mtsCallableVoidReturnMethod<__classType, __resultType>(method, classInstantiation),
                                          commandName,
                                          mtsGenericTypes<__resultType>::ConditionalCreate(resultPrototype, commandName),
                                          queueingPolicy);
    }
 
    template <class __classType, class __resultType>
    inline mtsCommandVoidReturn * AddCommandVoidReturn(void (__classType::*method)(__resultType &),
                                                       __classType * classInstantiation,
                                                       const std::string & commandName,
                                                       mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandVoidReturn(new mtsCallableVoidReturnMethod<__classType, __resultType>(method, classInstantiation),
                                          commandName,
                                          mtsGenericTypes<__resultType>::ConditionalCreate(__resultType(), commandName),
                                          queueingPolicy);
    }


    template <class __classType, class __argumentType>
    inline mtsCommandWriteBase * AddCommandWrite(void (__classType::*method)(const __argumentType &),
                                                 __classType * classInstantiation,
                                                 const std::string & commandName,
                                                 const __argumentType & argumentPrototype,
                                                 mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandWrite(new mtsCommandWrite<__classType, __argumentType>(method, classInstantiation, commandName, argumentPrototype),
                                     queueingPolicy);
    }
 
    template <class __classType, class __argumentType>
    inline mtsCommandWriteBase * AddCommandWrite(void (__classType::*method)(const __argumentType &),
                                                 __classType * classInstantiation,
                                                 const std::string & commandName,
                                                 mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandWrite<__classType, __argumentType>(method, classInstantiation, commandName, __argumentType(),
                                                                  queueingPolicy);
    }


    template <class __classType, class __argumentType, class __resultType>
    inline 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) {
        return this->AddCommandWriteReturn(new mtsCallableWriteReturnMethod<__classType, __argumentType, __resultType>(method, classInstantiation),
                                          commandName,
                                          mtsGenericTypes<__argumentType>::ConditionalCreate(argumentPrototype, commandName),
                                          mtsGenericTypes<__resultType>::ConditionalCreate(resultPrototype, commandName),
                                          queueingPolicy);
    }
 
    template <class __classType, class __argumentType, class __resultType>
    inline mtsCommandWriteReturn * AddCommandWriteReturn(void (__classType::*method)(const __argumentType &, __resultType &),
                                                         __classType * classInstantiation,
                                                         const std::string & commandName,
                                                         mtsCommandQueueingPolicy queueingPolicy = MTS_INTERFACE_COMMAND_POLICY) {
        return this->AddCommandWriteReturn(new mtsCallableWriteReturnMethod<__classType, __argumentType, __resultType>(method, classInstantiation),
                                           commandName,
                                           mtsGenericTypes<__argumentType>::ConditionalCreate(__argumentType(), commandName),
                                           mtsGenericTypes<__resultType>::ConditionalCreate(__resultType(), commandName),
                                           queueingPolicy);
    }


    template <class __classType, class __argumentType>
    inline mtsCommandRead * AddCommandRead(void (__classType::*method)(__argumentType &) const,
                                           __classType * classInstantiation,
                                           const std::string & commandName,
                                           const __argumentType & argumentPrototype) {
        return this->AddCommandRead(new mtsCallableReadReturnVoidMethod<__classType, __argumentType>(method, classInstantiation),
                                    commandName,
                                    mtsGenericTypes<__argumentType>::ConditionalCreate(argumentPrototype, commandName));
    }
 
    template <class __classType, class __argumentType>
    inline mtsCommandRead * AddCommandRead(void (__classType::*method)(__argumentType &) const,
                                           __classType * classInstantiation,
                                           const std::string & commandName)
    {
        return this->AddCommandRead(new mtsCallableReadReturnVoidMethod<__classType, __argumentType>(method, classInstantiation),
                                    commandName,
                                    mtsGenericTypes<__argumentType>::ConditionalCreate(__argumentType(), commandName));
    }


    // Note: Could use string for state, rather than the variable
    template <class _elementType>
    mtsCommandRead * AddCommandReadState(const mtsStateTable & stateTable,
                                         const _elementType & stateData, const std::string & commandName);
 
    // Methods to read from State Table and then "filter" (convert) the result to a different data type
    // to be returned via the command pattern. The following conversion signatures are supported,
    // where _elementType is the type of the object in the State Table and _outputType is the data type
    // returned via the command pattern:
    //     bool _elementType::GetMethod(_outputType &output) const
    //     _outputType _elementType::GetMethod(void) const
    //     bool ConvertFunction(const _elementType &input, _outputType &output)
 
    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>
    inline mtsCommandQualifiedRead * AddCommandQualifiedRead(void (__classType::*method)(const __argument1Type &, __argument2Type &) const,
                                                             __classType * classInstantiation,
                                                             const std::string & commandName,
                                                             const __argument1Type & argument1Prototype,
                                                             const __argument2Type & argument2Prototype) {
        return this->AddCommandQualifiedRead(new mtsCallableQualifiedReadReturnVoidMethod<__classType, __argument1Type, __argument2Type>(method, classInstantiation),
                                             commandName,
                                             mtsGenericTypes<__argument1Type>::ConditionalCreate(argument1Prototype, commandName),
                                             mtsGenericTypes<__argument2Type>::ConditionalCreate(argument2Prototype, commandName));
     }
 
    template <class __classType, class __argument1Type, class __argument2Type>
    inline mtsCommandQualifiedRead * AddCommandQualifiedRead(void (__classType::*method)(const __argument1Type &, __argument2Type &) const,
                                                             __classType * classInstantiation,
                                                             const std::string & commandName) {
        return this->AddCommandQualifiedRead(new mtsCallableQualifiedReadReturnVoidMethod<__classType, __argument1Type, __argument2Type>(method, classInstantiation),
                                             commandName,
                                             mtsGenericTypes<__argument1Type>::ConditionalCreate(__argument1Type(), commandName),
                                             mtsGenericTypes<__argument2Type>::ConditionalCreate(__argument2Type(), commandName));
    }


    template <class __classType, class __argumentType, class __filteredType>
    inline 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) {
        std::string commandNameFilter(commandName + "Filter");
        return this->AddCommandFilteredWrite(new mtsCommandQualifiedRead(new mtsCallableQualifiedReadReturnVoidMethod<__classType, __argumentType, __filteredType>
                                                                         (premethod, classInstantiation),
                                                                         commandNameFilter,
                                                                         mtsGenericTypes<__argumentType>::ConditionalCreate(argumentPrototype, commandName),
                                                                         mtsGenericTypes<__filteredType>::ConditionalCreate(filteredPrototype, commandName)),
                                             new mtsCommandWrite<__classType, __filteredType>(method, classInstantiation, commandName, filteredPrototype),
                                             queueingPolicy);
    }
 
    template <class __classType, class __argumentType, class __filteredType>
    inline 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) {
        return this->AddCommandFilteredWrite(premethod, method, classInstantiation, commandName,
                                             __argumentType(), __filteredType(),
                                             queueingPolicy);
    }

#endif // SWIG

    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;
 
 protected:

    mtsInterfaceProvided(mtsInterfaceProvided * interfaceProvided,
                         const std::string & userName,
                         size_t mailBoxSize,
                         size_t argumentQueuesSize);
 
    static std::string GenerateEndUserInterfaceName(const mtsInterfaceProvided * originalInterface,
                                                    const std::string & userName);

public: // PK TEMP for IRE
    mtsInterfaceProvided * GetEndUserInterface(const std::string & userName);
protected: // PK TEMP

 
    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);

    typedef std::pair<size_t, ThisType *> InterfaceProvidedCreatedPairType;
    typedef std::list<InterfaceProvidedCreatedPairType> InterfaceProvidedCreatedListType;
    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; // internal commands (not exposed to user)

    std::vector<mtsStateTableFilterBase *> StateTableFilters;

    mtsCallableVoidBase * PostCommandQueuedCallable;
 
    struct {
        mtsFunctionWrite StatusEvent;
        mtsMessage StatusMessage;
        mtsFunctionWrite WarningEvent;
        mtsMessage WarningMessage;
        mtsFunctionWrite ErrorEvent;
        mtsMessage ErrorMessage;
    } mMessages;
 
    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;
};
 
 
 
#ifndef SWIG
 
template <class _elementType>
mtsCommandRead * mtsInterfaceProvided::AddCommandReadState(const mtsStateTable & stateTable,
                                                           const _elementType & stateData, const std::string & commandName)
{
    typedef typename mtsGenericTypes<_elementType>::FinalType FinalType;
    typedef typename mtsStateTable::Accessor<_elementType> AccessorType;
 
    AccessorType * stateAccessor = dynamic_cast<AccessorType *>(stateTable.GetAccessorByInstance(stateData));
    if (!stateAccessor) {
        CMN_LOG_CLASS_INIT_ERROR << "AddCommandReadState: invalid accessor for command " << commandName << std::endl;
        return 0;
    }
    // NOTE: qualified-read and read destructors will free the memory allocated below for the prototype objects.
    this->AddCommandQualifiedRead(new mtsCallableQualifiedReadMethod<AccessorType, mtsStateIndex, FinalType>(&AccessorType::Get, stateAccessor),
                                  commandName, new mtsStateIndex, new FinalType(stateData));
    return this->AddCommandRead(new mtsCallableReadMethod<AccessorType, FinalType>(&AccessorType::GetLatest, stateAccessor),
                                commandName, new FinalType(stateData));
}
 
template <class _elementType, class _outputType, class _filterMethod>
mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadStateInternal(const mtsStateTable & stateTable,
                                                                           const _elementType & stateData,
                                                                           _filterMethod filterMethod,
                                                                           const std::string & commandName)
{
    typedef typename mtsStateTable::Accessor<_elementType> AccessorType;
    typedef mtsStateTableFilter<_elementType, _outputType, _filterMethod> FilterType;
    typedef typename mtsGenericTypes<_outputType>::FinalType FinalType;
 
    AccessorType * stateAccessor = dynamic_cast<AccessorType *>(stateTable.GetAccessorByInstance(stateData));
    if (!stateAccessor) {
        CMN_LOG_CLASS_INIT_ERROR << "AddCommandFilteredReadState: invalid accessor for command " << commandName << std::endl;
        return 0;
    }
    // Create state table filter object
    FilterType *stf = new FilterType(stateAccessor, filterMethod);
    // Store filter object (only used for cleanup)
    StateTableFilters.push_back(stf);
    // NOTE: qualified-read and read destructors will free the memory allocated below for the prototype objects.
    this->AddCommandQualifiedRead(new mtsCallableQualifiedReadMethod<FilterType, mtsStateIndex, _outputType>(&FilterType::GetFiltered, stf),
                                  commandName, new mtsStateIndex, new FinalType);
    return this->AddCommandRead(new mtsCallableReadMethod<FilterType, _outputType>(&FilterType::GetLatestFiltered, stf),
                                commandName, new FinalType);
}
 
template <class _elementType, class _outputType>
mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadState(const mtsStateTable & stateTable,
                                                                   const _elementType & stateData,
                                                                   bool (_elementType::*getMethod)(_outputType &) const,
                                                                   const std::string & commandName)
{
    typedef bool (_elementType::*FilterMethodType)(_outputType &) const;
    return AddCommandFilteredReadStateInternal<_elementType, _outputType, FilterMethodType>(stateTable, stateData, getMethod, commandName);
}
 
template <class _elementType, class _outputType>
mtsCommandRead * mtsInterfaceProvided::AddCommandFilteredReadState(const mtsStateTable & stateTable,
                                                                   const _elementType & stateData,
                                                                   _outputType (_elementType::*getMethod)(void) const,
                                                                   const std::string & commandName)
{
    typedef _outputType (_elementType::*FilterMethodType)(void) const;
    return AddCommandFilteredReadStateInternal<_elementType, _outputType, FilterMethodType>(stateTable, stateData, getMethod, commandName);
}
 
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)
{
    typedef bool (*FilterMethodType)(const _elementType &, _outputType &);
    return AddCommandFilteredReadStateInternal<_elementType, _outputType, FilterMethodType>(stateTable, stateData, convertFunction, commandName);
}
 
template <class _elementType>
mtsCommandRead * mtsInterfaceProvided::AddCommandReadStateDelayed(const mtsStateTable & stateTable,
                                                                  const _elementType & stateData, const std::string & commandName)
{
    typedef typename mtsGenericTypes<_elementType>::FinalType FinalType;
    typedef typename mtsStateTable::Accessor<_elementType> AccessorType;
 
    AccessorType * stateAccessor = dynamic_cast<AccessorType *>(stateTable.GetAccessorByInstance(stateData));
    if (!stateAccessor) {
        CMN_LOG_CLASS_INIT_ERROR << "AddCommandReadState: invalid accessor for command " << commandName << std::endl;
        return 0;
    }
    // NOTE: qualified-read and read destructors will free the memory allocated below for the prototype objects.
    return this->AddCommandRead(new mtsCallableReadMethod<AccessorType, FinalType>(&AccessorType::GetDelayed, stateAccessor),
                                commandName, new FinalType(stateData));
}
 
template <class _elementType>
mtsCommandWriteBase * mtsInterfaceProvided::AddCommandWriteState(const mtsStateTable & stateTable,
                                                                 const _elementType & stateData,
                                                                 const std::string & commandName,
                                                                 mtsCommandQueueingPolicy queueingPolicy)
{
    typedef typename mtsGenericTypes<_elementType>::FinalType FinalType;
    typedef typename mtsStateTable::Accessor<_elementType> AccessorType;
    AccessorType * stateAccessor = dynamic_cast<AccessorType *>(stateTable.GetAccessorByInstance(stateData));
    if (!stateAccessor) {
        CMN_LOG_CLASS_INIT_ERROR << "AddCommandWriteState: invalid accessor for command " << commandName << std::endl;
        return 0;
    }
    return this->AddCommandWrite(new mtsCommandWrite<AccessorType, FinalType>
                                 (&AccessorType::SetCurrent, stateAccessor, commandName, FinalType(stateData)),
                                 queueingPolicy);
}
 
template <class __argumentType>
mtsCommandWriteBase * mtsInterfaceProvided::AddEventWrite(const std::string & eventName,
                                                          const __argumentType & argumentPrototype) {
    mtsMulticastCommandWriteBase * eventMulticastCommand = new mtsMulticastCommandWrite<__argumentType>(eventName, argumentPrototype);
    if (eventMulticastCommand) {
        if (AddEvent(eventName, eventMulticastCommand)) {
            return eventMulticastCommand;
        }
        delete eventMulticastCommand;
        CMN_LOG_CLASS_INIT_ERROR << "AddEventWrite: unable to add event \""
                                 << eventName << "\"" << std::endl;
        return 0;
    }
    CMN_LOG_CLASS_INIT_ERROR << "AddEventWrite: unable to create multi-cast command for event \""
                             << eventName << "\"" << std::endl;
    return 0;
}
 
 
template <class __argumentType>
bool mtsInterfaceProvided::AddEventWrite(mtsFunctionWrite & eventTrigger, const std::string & eventName,
                                         const __argumentType & argumentPrototype) {
    mtsCommandWriteBase * command;
    command = this->AddEventWrite(eventName, argumentPrototype);
    if (command) {
        eventTrigger.Bind(command);
        return true;
    }
    return false;
}
 
#endif // SWIG
 
 
CMN_DECLARE_SERVICES_INSTANTIATION(mtsInterfaceProvided)
 
#endif // _mtsInterfaceProvided_h