Broadcast destination = 0x00ff0000;
Local destination = 0x0000xxxx;

Handle application part                   : 0xxxxx0000;
Handle CDPObject part                     : 0x0000xxxx;
Messenger destination handle for broadcast: 0x00ffxxxx;
Messenger destination handle for local    : 0x0000xxxx;

#define HANDLE_APPLICATIONPART(X)   (X >> 16)
#define HANDLE_COMPONENTPART(X)     (X & 0x0000ffff)

Member Function Documentation

[protected] Messenger::Messenger()

Default constructs an instance of Messenger.

[virtual] Messenger::~Messenger()

Destroys the instance of Messenger. The destructor is virtual.

[override virtual] void Messenger::Activate()

Reimplemented from CDPBaseObject::Activate().

Activate the messenger to enable message communication.

[static] void Messenger::AddGlobalAppConnectedHandler(const std::function<void( unsigned int ) > &myAppConnectedHandler)

Adds an Application Connected Handler function myAppConnectedHandler

Example code if you want to add a function in class MyClass, which will be called after another application is connected by Messenger: otherAppNumber will be in range [1..MESSENGER_MAXNUMBEROFAPPLICATIONS]:

#include <functional>
...
using namespace std::placeholders;
Messenger::AddGlobalAppConnectedHandler( std::bind(&MyClass::AppConnectedHandler, this, _1) );

where AppConnectedHandler is declared as

void AppConnectedHandler(unsigned int otherAppNumber);

[static] void Messenger::AddGlobalAppDisconnectedHandler(const std::function<void( unsigned int ) > &myAppDisconnectedHandler)

Adds an Application Disconnected Handler function myAppDisconnectedHandler

Example code if you want to add a function in class MyClass, which will be called after another application is disconnected by Messenger. otherAppNumber will be in range [1..MESSENGER_MAXNUMBEROFAPPLICATIONS]:

#include <functional>
...
using namespace std::placeholders;
Messenger::AddGlobalAppDisconnectedHandler( std::bind(&MyClass::AppDisconnectedHandler, this, _1) );

where AppDisconnectedHandler is declared as

void AppDisconnectedHandler(unsigned int otherAppNumber);

[static] void Messenger::AddGlobalAppUpdatedHandler(const std::function<void( const std::string & appName, unsigned int oldHandle, unsigned int newHandle ) > &myAppUpdatedHandler)

Adds an Application Updated Handler function myAppUpdatedHandler which is called when the application handle is changed or when any of the ApplicationConnector fields are changed.

Example code if you want to add a function in class MyClass, which will be called after another application handle is changed or its fields are updated by Messenger: oldHandle and newHandle will be in range [1..MESSENGER_MAXNUMBEROFAPPLICATIONS]:

#include <functional>
...
using namespace std::placeholders;
Messenger::AddGlobalAppUpdatedHandler( std::bind(&MyClass::AppUpdatedHandler, this, _1, _2, _3) );

where AppUpdatedHandler is declared as

void AppUpdatedHandler(const std::string& appName, unsigned int oldHandle, unsigned int newHandle);

unsigned int Messenger::AppHandle()

Returns the application handle of this application.

Note: Lower 16 bits are 0, application number is in upper 16 bits. (AppHandle() == ThisApp() << 16).

unsigned int Messenger::AppNumber()

Returns the high-word handle number of this application (ThisApp() == AppHandle() >> 16).

const ApplicationConnector *Messenger::ApplicationConnectionData() const

ApplicationData returns pointer to array of ApplicationConnector objects with size of MESSENGER_MAXNUMBEROFAPPLICATIONS+1

Position 0 should be ignored as that contains broadcast connector info.

[override virtual] void Messenger::Configure(const char *xml)

[virtual] void Messenger::Create(const char *fullName, const IpAddress ipAddress)

Creates the messenger.

[override virtual protected] void Messenger::CreateModel()

Reimplemented from CDPBaseObject::CreateModel().

Create the Messenger Model

void Messenger::DebugDisplayApplicationList()

Display connected applications on CDPMessages debug interface.

[override virtual] void Messenger::Destroy()

int Messenger::GetApplicationHandle(const char *application)

Returns application handle for application name.

Returns 0 if name not found.

int Messenger::GetApplicationHandle(unsigned int applicationNumber)

Returns application handle for application number.

Returns 0 if number is not valid or an application with this slot number is not connected.

IpAddress Messenger::GetApplicationIpAddress(unsigned int applicationNumber)

Returns an application's IP-address.

const char *Messenger::GetApplicationName(unsigned int applicationHandle)

Returns name of application from applicastion number or handle.

Automatically adjusts applicationHandle parameter, will interpret as number if 0x0000XXXX, handle if 0xXXXX0000.

Returns "" if not found. Will also work for the local application.

[static] Messenger *Messenger::GetInstance()

Return the Messenger Singleton instance, create it if it is not yet created.

IpAddress *Messenger::GetIpAddress()

Return the IPAddress that the messenger is using.

unsigned int Messenger::GetNextMessageId()

Returns a new message Id to be used in the header when sending messages.

int Messenger::GetNumberOfApplications()

Returns highest connected application number.

Does not necessarily equal number of applications in the system, slots within this range may be free.

Note: Only remote applications are included, thisApp may be higher.

void Messenger::HandleMessageReceipt(Message *pMsg)

Handles CM_MESSAGERECEIPT messages. Will remove message waiting for receipt from SendBuffer.

[protected] void Messenger::HandleReceive(const MessageReceiver &receiver)

The receive message task.

Receives message from remote applications and delivers local application destination messages to CDPEngine.

bool Messenger::IsCommError()

Check if communication is running.

[override virtual] bool Messenger::IsReadyToActivate()

bool Messenger::IsSendSocketNonBlocking()

Return the non-blocking mode of Messengers sendsocket.

[protected] void Messenger::ProcessInit()

Init process sends application ping requests.

Will enter 'Running' after timeout.

[protected] void Messenger::ProcessReceive(OSAPITask &receiveTask)

[protected] void Messenger::ProcessRetry()

The retry send message process.

[protected] void Messenger::ProcessRunning()

Running process does periodic maintenance:

• Sends application notify at periodic interval.
• Monitors connected applications for timeout and diconnects lost applications
• Updates messenger and network system information values.

[protected] void Messenger::ProcessSend()

The send message process.

Sends all messages to remote applications.

[protected] void Messenger::ProcessStop()

Sets requestedState to "Init".

[override virtual] int Messenger::ReceiveMessage(void *message)

Reimplemented from CDPBaseObject::ReceiveMessage().

Handle messages sent to the Messenger.

Returns > 1 if the message was handled.

[protected] void Messenger::SendApplicationPing()

Send application notify request broadcast message.

[virtual] unsigned int Messenger::SendMessage(Message *msg, bool retryEnabled = true)

[virtual] unsigned int Messenger::SendMessage(const MessagePacketHandle &message)

Send a Message message.

This method is reentrant- safe and may be called at any time from any thread.

Local messages are delivered to CDPEngine immediately. Remote messages are buffered and will be sent from the send message task.

Messages are handled by engine. Engine stores messages in a buffer.

• Set retryEnabled = false to avoid receipt (typically for periodic messages).
• SendMessage() returns a message ID for the message.
• If the message is sent with retry, the calling object's MessageConfirm() or MessageTimeout() is called with a MessageACK message containing the original message and the messageID.
• Note that SendMessage() can return '0' if the message sending fails in an early stage (typically no network or buffer full).
• When SendMessage returns 0, the calling objects MessageTimeout() function is NOT called.

void Messenger::SetLocalMessageQueueFullAlarm(const std::string &processName)

Set alarm alerting that some Message queue is full

[protected] bool Messenger::SizeAndDomainMatching(MessageApplicationNotify *pMsgAN)

Returns true if parameter-size is OK and domain matches, false if not.

[virtual] void Messenger::Stop()

Suspend the messenger so that messages are no longer transmitted.

const char *Messenger::ThisAppName()

Returns the name of this application.

[protected] bool Messenger::TransitionInitToRunning()

Will go from state Init to Running if requestedState is "Running". requestedState is set to "Running" in ProcessInit() after a timeout.

• On entry: Restarts timer to start sending Notify-messages.
• On entry: Find new, free application handle

[protected] bool Messenger::TransitionNullToStop()

Initial state transition, will always go from Null to Stop.

[protected] bool Messenger::TransitionRunningToStop()

Will go from state Running to Stop if requestedState is "Running".: requestedState is only set to "Stop" when Application is stopping.

• On entry: Send CM_APPLICATIONSTOPPED message to all applications.

[protected] bool Messenger::TransitionStopToInit()

Will go from state Stop to Init if requestedState is "Init". requestedState is set to "Init" in ProcessStop() and in Activate().

• On entry: Start the find- all- computers- in- local- network- segment process.
• On entry: Restarts some timers.
• On entry: Create broadcast connectors if necessary.
• Does not send notify messages from this application now, only ping.

[protected] void Messenger::UpdateApplication(MessageApplicationNotify *pMsgAN)

Update application connection.

Connects application if not connected, verifies ip adress and port number, resets connection timeout.

void Messenger::UpdateApplicationName()

Update local application name copy from application component.

[virtual] void Messenger::UpdateApplicationNotifyMsg(MessageApplicationNotify &msgAN)

Updates contents (not header) of a MessageApplicationNotify-msg.

void Messenger::UseNonBlockingSendSocket(bool bUseNonBlockingSocket)

Set if Messenger should use a non-blocking send-socket or not.

[override virtual] bool Messenger::ValidatePropertyHandler(CDP::StudioAPI::CDPVariantValue &newValue, CDPPropertyBase *property)

bool Messenger::VerifyApplicationConnected(unsigned int applicationHandle)

Return true if this application is connected.

Automatically adjusts applicationHandle parameter, will interpret as number if 0x0000XXXX, handle if 0xXXXX0000.

[static protected] OSAPITASK Messenger::taskHandleReceive(OSAPITASK_ARG)

Wrap to Messenger::GetInstance()->ProcessReceive(...).

[static protected] OSAPITASK Messenger::taskHandleReceiveBroadcast(OSAPITASK_ARG)

Wrap to Messenger::GetInstance()->ProcessReceive(...).

[static protected] OSAPITASK Messenger::taskProcessReceive(OSAPITASK_ARG)

[static protected] OSAPITASK Messenger::taskRetry(OSAPITASK_ARG)

Wrap to Messenger::GetInstance()->ProcessRetry();

[static protected] OSAPITASK Messenger::taskSend(OSAPITASK_ARG)

Wrap to Messenger::GetInstance()->ProcessSend();