BaseChannelImpl.h File Reference

#include <chrono>
#include <deque>
#include <iostream>
#include <map>
#include <memory>
#include <boost/noncopyable.hpp>
#include <boost/asio.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include "ChannelEventsImpl.h"
#include "ChannelMessageHandlersImpl.h"
#include "CommandAttachmentImpl.h"
#include "Logger.h"
#include "MonitoringThread.h"
#include "StatImpl.h"

Go to the source code of this file.

Classes
class	dds::protocol_api::CClientChannelImpl< T >
class	dds::protocol_api::CServerChannelImpl< T >
struct	dds::protocol_api::SBinaryAttachmentInfo
class	dds::protocol_api::CBaseChannelImpl< T >

Namespaces
	dds
	dds::protocol_api

Macros
#define	BEGIN_MSG_MAP(theClass)
#define	MESSAGE_HANDLER(msg, func)
#define	END_MSG_MAP()
#define	REGISTER_DEFAULT_REMOTE_ID_STRING

Typedefs
typedef std::vector< EChannelType >	dds::protocol_api::channelTypeVector_t
typedef std::shared_ptr< SBinaryAttachmentInfo >	dds::protocol_api::binaryAttachmentInfoPtr_t

Enumerations
enum	dds::protocol_api::EChannelType { dds::protocol_api::UNKNOWN = 0, dds::protocol_api::AGENT, dds::protocol_api::UI, dds::protocol_api::API_GUARD }

Variables
const std::array< std::string, 5 >	dds::protocol_api::gChannelTypeName

Macro Definition Documentation

BEGIN_MSG_MAP

#define BEGIN_MSG_MAP

(

theClass

)

END_MSG_MAP

#define END_MSG_MAP

(

)

Value:

default:                                                                                                  \
        LOG(MiscCommon::error) << "The received message doesn't have a handler: " << _currentMsg->toString(); \
        }                                                                                                     \
        }                                                                                                     \
        catch (std::exception & _e)                                                                           \
        {                                                                                                     \
            LOG(MiscCommon::error) << "Channel processMessage: " << _e.what();                                \
        }                                                                                                     \
        }

MESSAGE_HANDLER

#define MESSAGE_HANDLER	(		msg,
			func
	)

Value:

case msg:                                                                                                      \
    {                                                                                                              \
        typedef typename SCommandAttachmentImpl<msg>::ptr_t attahcmentPtr_t;                                       \
        attahcmentPtr_t attachmentPtr = SCommandAttachmentImpl<msg>::decode(_currentMsg);                          \
        LOG(MiscCommon::debug) << "Processing " << g_cmdToString[msg] << " received from " << remoteEndIDString(); \
        processed = func(attachmentPtr);                                                                           \
        if (!processed)                                                                                            \
        {                                                                                                          \
            if (getNofMessageHandlers<msg>() == 0)                                                                 \
            {                                                                                                      \
                LOG(MiscCommon::error) << "The received message was not processed and has no registered handler: " \
                                       << _currentMsg->toString();                                                 \
            }                                                                                                      \
            else                                                                                                   \
            {                                                                                                      \
                dispatchMessageHandlers(msg, attachmentPtr, this);                                                 \
            }                                                                                                      \
        }                                                                                                          \
        break;                                                                                                     \
    }

REGISTER_DEFAULT_REMOTE_ID_STRING

#define REGISTER_DEFAULT_REMOTE_ID_STRING

Value:

std::string _remoteEndIDString()      \
    {                                     \
        return "DDS Server";              \
    }