Intercom.h

Go to the documentation of this file.

// Copyright 2014 GSI, Inc. All rights reserved.
//
//
//
#ifndef DDS_INTERCOM_H_
#define DDS_INTERCOM_H_
// DDS
#include "IntercomErrorCodes.h"
// STD
#include <ostream>
#include <string>
// BOOST
#include <boost/property_tree/json_parser.hpp>
#include <boost/signals2/signal.hpp>

namespace dds
{
    namespace internal_api
    {
        class CIntercomServiceCore;
    }

    namespace intercom_api
    {
        // DDS intercom service
        class CIntercomService
        {
          public:
            typedef boost::signals2::signal<void(uint64_t /*_taskID*/, uint32_t /*_exitCode*/)> taskDoneSignal_t;

          public:
            CIntercomService();
            ~CIntercomService();

            void subscribeOnError(errorSignal_t::slot_function_type _subscriber);
            void subscribeOnTaskDone(taskDoneSignal_t::slot_function_type _subscriber);
            void start(const std::string& _sessionID = "");

            // FIXME: workaround for old functionality. This functions will be removed in the future releases.
            void waitCondition();
            void stopCondition();

          private:
            friend class CKeyValue;
            friend class CCustomCmd;
            std::shared_ptr<internal_api::CIntercomServiceCore> m_impl;
        };

        // DDS key-value
        class CKeyValue
        {
          public:
            typedef boost::signals2::signal<void(
                const std::string& /*_propertyName*/, const std::string& /*_value*/, uint64_t /*_senderTaskID*/)>
                signal_t;

          public:
            CKeyValue(CIntercomService& _service);
            ~CKeyValue();

          public:
            void putValue(const std::string& _key, const std::string& _value);
            void subscribe(signal_t::slot_function_type _subscriber);
            void unsubscribe();

          private:
            CIntercomService& m_service; 
        };

        // DDS custom commands
        class CCustomCmd
        {
          public:
            typedef boost::signals2::signal<void(
                const std::string& /*_command*/, const std::string& /*_condition*/, uint64_t /*_senderID*/)>
                signal_t;
            typedef boost::signals2::signal<void(const std::string&)> replySignal_t;

          public:
            CCustomCmd(CIntercomService& _service);
            ~CCustomCmd();

          public:
            void send(const std::string& _command, const std::string& _condition);
            void subscribe(signal_t::slot_function_type _subscriber);
            void subscribeOnReply(replySignal_t::slot_function_type _subscriber);
            void unsubscribe();

          private:
            CIntercomService& m_service; 
        };

        // DDS RMS plugins

        const std::string g_sRmsAgentSign = "rms_agent_sign";
        const std::string g_sToolsAPISign = "tools_api_sign";

        enum class EMsgSeverity
        {
            info, 
            error 
        };

        inline std::ostream& operator<<(std::ostream& _os, EMsgSeverity _severity)
        {
            switch (_severity)
            {
                case EMsgSeverity::info:
                    return _os << "info";
                case EMsgSeverity::error:
                default:
                    return _os << "error";
            }
        }

        struct SSubmit
        {
            SSubmit();

            std::string toJSON();

            void fromJSON(const std::string& _json);

            void fromPT(const boost::property_tree::ptree& _pt);

            bool operator==(const SSubmit& _val) const;

            uint32_t m_nInstances;        
            uint32_t m_slots;             
            std::string m_cfgFilePath;    
            std::string m_id;             
            std::string m_wrkPackagePath; 
        };

        struct SMessage
        {
            SMessage();

            std::string toJSON();

            void fromJSON(const std::string& _json);

            void fromPT(const boost::property_tree::ptree& _pt);

            bool operator==(const SMessage& _val) const;

            EMsgSeverity m_msgSeverity; 
            std::string m_msg;          
            std::string m_id;           
        };

        struct SInit
        {
            SInit();

            std::string toJSON();

            void fromJSON(const std::string& _json);

            void fromPT(const boost::property_tree::ptree& _pt);

            bool operator==(const SInit& _val) const;

            std::string m_id; 
        };

        class CRMSPluginProtocol
        {
          public:
            typedef boost::signals2::signal<void(const SSubmit&)> signalSubmit_t;

            typedef boost::signals2::signal<void(const SMessage&)> signalMessage_t;

          public:
            CRMSPluginProtocol(const std::string& _id);

            ~CRMSPluginProtocol();

          public:
            void onSubmit(signalSubmit_t::slot_function_type _subscriber);

            void onMessage(signalMessage_t::slot_function_type _subscriber);

            void sendMessage(EMsgSeverity _severity, const std::string& _msg);

            void start(bool _block = true);

            void stop();

          protected:
            void notify(std::istream& _stream);

          private:
            void unsubscribe();

            signalSubmit_t m_signalSubmit;   
            signalMessage_t m_signalMessage; 

            std::string m_id; 

            CIntercomService m_service; 
            CCustomCmd m_customCmd;     
        };
    } // namespace intercom_api
} // namespace dds

#endif /* DDS_INTERCOM_H_ */