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-2014 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 <cisstMultiTask/mtsMailBox.h>
#include <cisstMultiTask/mtsStateTable.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/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 dynamically create and add command proxies and event proxies
    friend class mtsComponentProxy;
    // To get information about event generators in this interface
    friend class mtsManagerLocal;
    // To call GetEndUserInterface
    friend class mtsComponent;
    friend class mtsManagerComponentClient;

    // to allow adding command write generic ...
    friend class mtsComponentAddLatency;
    friend class mtsSocketProxyClient;
    friend class mtsSocketProxyServer;

 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,
                         bool isProxy = false);

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

    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;
    mtsCommandVoidReturn * GetCommandVoidReturn(const std::string & commandName) const;
    mtsCommandWriteBase * GetCommandWrite(const std::string & commandName) const;
    mtsCommandWriteReturn * GetCommandWriteReturn(const std::string & commandName) const;
    mtsCommandRead * GetCommandRead(const std::string & commandName) const;
    mtsCommandQualifiedRead * GetCommandQualifiedRead(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);

    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);
    bool AddObserver(const std::string & eventName, mtsCommandWriteBase * handler);
    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);

    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;

 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;

    bool IsProxy;

    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)

    mtsCallableVoidBase * PostCommandQueuedCallable;

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

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

    bool AddSystemEvents(void);

    bool GetDescription(mtsInterfaceProvidedDescription & providedInterfaceDescription);
};



#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.GetAccessor(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>
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.GetAccessor(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.GetAccessor(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