mtsManagerComponentServer.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):  Min Yang Jung
  Created on: 2010-08-29

  (C) Copyright 2010-2013 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 _mtsManagerComponentServer_h
#define _mtsManagerComponentServer_h

#include <cisstMultiTask/mtsManagerComponentBase.h>

class mtsManagerGlobal;

class mtsManagerComponentServer : public mtsManagerComponentBase
{
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);

    friend class mtsManagerLocal;

protected:
    mtsManagerGlobal * GCM;

    bool AddInterfaceGCM(void);

    void GetNamesOfProcesses(std::vector<std::string> & processList) const;

    typedef struct {
        mtsFunctionWriteReturn ComponentCreate;
        mtsFunctionWrite ComponentConfigure;
        mtsFunctionWrite ComponentConnect;
        mtsFunctionWrite ComponentDisconnect;
        mtsFunctionWrite ComponentStart;
        mtsFunctionWrite ComponentStop;
        mtsFunctionWrite ComponentResume;
        mtsFunctionQualifiedRead ComponentGetState;
        mtsFunctionQualifiedRead GetInterfaceProvidedDescription;
        mtsFunctionQualifiedRead GetInterfaceRequiredDescription;
        mtsFunctionQualifiedRead LoadLibrary;
        mtsFunctionWrite SetLogForwarding;
        mtsFunctionRead GetLogForwardingState;
        mtsFunctionRead GetAbsoluteTimeInSeconds;
        mtsFunctionRead GetListOfComponentClasses;
    } InterfaceGCMFunctionType;

    typedef cmnNamedMap<InterfaceGCMFunctionType> InterfaceGCMFunctionMapType;
    InterfaceGCMFunctionMapType InterfaceGCMFunctionMap;

    mtsFunctionWrite EventPrintLog;

    void InterfaceGCMCommands_ComponentCreate(const mtsDescriptionComponent & componentDescription, bool & result);
    void InterfaceGCMCommands_ComponentConfigure(const mtsDescriptionComponent & arg);
    void InterfaceGCMCommands_ComponentConnect(const mtsDescriptionConnection & connectionDescription /*, bool & result*/);
    void InterfaceGCMCommands_ComponentDisconnect(const mtsDescriptionConnection & arg);
    void InterfaceGCMCommands_ComponentStart(const mtsComponentStatusControl & arg);
    void InterfaceGCMCommands_ComponentStop(const mtsComponentStatusControl & arg);
    void InterfaceGCMCommands_ComponentResume(const mtsComponentStatusControl & arg);
    void InterfaceGCMCommands_ComponentGetState(const mtsDescriptionComponent &component, mtsComponentState &state) const;
    void InterfaceGCMCommands_GetNamesOfProcesses(std::vector<std::string> & names) const;
    void InterfaceGCMCommands_GetNamesOfComponents(const std::string & processName,
                                                   std::vector<std::string> & names) const;
    void InterfaceGCMCommands_GetNamesOfInterfaces(const mtsDescriptionComponent & component, mtsDescriptionInterface & interfaces) const;
    void InterfaceGCMCommands_GetListOfConnections(std::vector <mtsDescriptionConnection> & listOfConnections) const;
    void InterfaceGCMCommands_GetInterfaceProvidedDescription(const mtsDescriptionInterface & intfc, mtsInterfaceProvidedDescription & description) const;
    void InterfaceGCMCommands_GetInterfaceRequiredDescription(const mtsDescriptionInterface & intfc, mtsInterfaceRequiredDescription & description) const;
    void InterfaceGCMCommands_LoadLibrary(const mtsDescriptionLoadLibrary & lib, bool & result) const;
    void InterfaceGCMCommands_PrintLog(const mtsLogMessage & log);
    void InterfaceGCMCommands_SetLogForwarding(const std::vector<std::string> & processNames, bool state);  // internal
    void InterfaceGCMCommands_EnableLogForwarding(const std::vector<std::string> & processNames);
    void InterfaceGCMCommands_DisableLogForwarding(const std::vector<std::string> & processNames);
    void InterfaceGCMCommands_GetLogForwardingStates(const stdStringVec & processNames, stdCharVec & states) const;
    void InterfaceGCMCommands_GetAbsoluteTimeDiffs(const std::vector<std::string> & processNames,
                                                   std::vector<double> & processTimes) const;
    void InterfaceGCMCommands_GetListOfComponentClasses(const std::string & processName,
                                                        std::vector<mtsDescriptionComponentClass> & listOfComponentClasses) const;

    mtsFunctionWrite InterfaceGCMEvents_AddComponent;
    mtsFunctionWrite InterfaceGCMEvents_AddConnection;
    mtsFunctionWrite InterfaceGCMEvents_RemoveConnection;
    mtsFunctionWrite InterfaceGCMEvents_ChangeState;
    mtsFunctionVoid InterfaceGCMEvents_MCSReady;

    // Event handler of InterfaceGCM's required interface
    void HandleChangeStateEvent(const mtsComponentStateChange &stateChange);

    mtsManagerComponentServer(mtsManagerGlobal * gcm);
    ~mtsManagerComponentServer();

public:
    void Startup(void);
    void Run(void);
    void Cleanup(void);

    bool AddNewClientProcess(const std::string & clientProcessName);

    void AddComponentEvent(const mtsDescriptionComponent &component);
    void AddConnectionEvent(const mtsDescriptionConnection &connection);
    void RemoveConnectionEvent(const mtsDescriptionConnection &connection);
    // If connection between InterfaceGCM.required - InterfaceLCM.provided is
    // disconnected, required interface instance of InterfaceGCM that corresponds
    // to the connection should be removed.
    bool DisconnectCleanup(const std::string & processName);

    // Calls LCM::DisconnectLocally()
    void ComponentDisconnect(const std::string & processName, const mtsDescriptionConnection & arg);
};

CMN_DECLARE_SERVICES_INSTANTIATION(mtsManagerComponentServer);

#endif // _mtsManagerComponentServer_h