gzDistRouterEngine.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistRouterEngine.h
// Module       : gzRemoteDistribution
// Description  : Router application for routing distribution messages between
//                different kinds of communication transports.
// Author       : Christian Andersson
// Product      : GizmoDistribution 2.1.1
//      
// Copyright © 2004 - Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoDistribution is a toolkit used for implementing distributed 
//          objects and events in C++
//
//
// Revision History...
//
// Who  Date    Description
//
// CAN  040811  Created file
//
//*****************************************************************************
#ifndef __GZ_DIST_ROUTER_ENGINE_H__
#define __GZ_DIST_ROUTER_ENGINE_H__

// Includes
#include "gzBaseLibrary.h"
#include "gzDistBase.h"
#include "gzDistSerializeMemory.h"
#include "gzDistRemoteChannel.h"

// Forward declarations
class gzDistTransportInterface;

//----------------------------- gzDistRouterTransportQueueInfo ----------------------------

class gzDistRouterTransportQueueInfo
{
    public:
        gzDistRouterTransportQueueInfo() : inQueue(0), outQueue(0), inAccum(0), outAccum(0) {}
        ~gzDistRouterTransportQueueInfo(){}

        gzUInt inQueue;
        gzUInt inAccum;
        gzUInt outQueue;
        gzUInt outAccum;
};

//----------------------------- gzDistRouterBuffer ----------------------------

// Internal
class gzDistRouterBuffer : public gzDistThreadSafeReference
{
    public:
        gzDistRouterBuffer();
        virtual ~gzDistRouterBuffer();

        // The data buffer.
        gzUByte data[GZ_DIST_MESSAGE_BUFFER_SIZE * GZ_DIST_MAX_CODED_BUFFER_FACTOR];

        gzUInt length;
};

//--------------------------- gzDistRouterTransport ---------------------------

// Internal
class gzDistRouterTransport : public gzThread
{
    public:
        gzDistRouterTransport(gzDistTransportInterface* transport);

        virtual ~gzDistRouterTransport();

        // Get a message from m_inMessages.
        gzBool getMessage(gzDistRouterBufferPtr& message);

        // Put a message in m_outMessages.
        // If the message queue is greater than queueLimit, the messages not be inserted.
        // queueLimit = 0 is unlimited queue size.
        gzBool addMessage(gzDistRouterBuffer* message, gzUInt queueLimit);

        // Get the transport.
        gzDistTransportInterface* getTransportInterface();

        gzDistRouterTransportQueueInfo getQueueInfo();

    protected:

        // Virtual function from gzThread.
        gzVoid process();

    private:

        // Put a message in m_inMessages.
        gzVoid addInMessage(gzDistRouterBuffer* message);

        // Get a message from m_outMessages.
        gzBool getOutMessage(gzDistRouterBufferPtr& message);

        // Clear m_outMessages.
        gzVoid clearOutMessages();

        // Mutex for m_inMessages.
        gzMutex m_inMessageLocker;

        // Mutex for m_outMessages.
        gzMutex m_outMessageLocker;

        // Messages received from m_transport.
        gzRefList<gzDistRouterBuffer> m_inMessages;
        
        // Messges from router.
        gzRefList<gzDistRouterBuffer> m_outMessages;

        // The transport.
        gzDistTransportInterface* m_transport;

        gzUInt m_inMessagesAccum;

        gzUInt m_outMessagesAccum;

        // True while running.
        gzBool m_run;
};


//---------------------------- gzDistRouterEngine ---------------------------


class gzDistRouterEngine : public gzThread
{
    public:

        GZ_REMOTE_EXPORT gzDistRouterEngine();

        GZ_REMOTE_EXPORT virtual ~gzDistRouterEngine();

        GZ_REMOTE_EXPORT gzBool addTransport(gzDistTransportInterface* transportInterface);

        GZ_REMOTE_EXPORT gzBool removeTransport(gzDistTransportInterface* transportInterface);

        GZ_REMOTE_EXPORT gzBool hasTransport(gzDistTransportInterface* transportInterface);

        GZ_REMOTE_EXPORT gzBool hasTransports();

        GZ_REMOTE_EXPORT gzULong getPPS(gzBool reset);

        GZ_REMOTE_EXPORT gzULong getRoutedBytes(gzBool reset);

        GZ_REMOTE_EXPORT gzVoid routeAllData(gzBool route);

        GZ_REMOTE_EXPORT gzDistRouterTransportQueueInfo getMessageQueueInfo(gzDistTransportInterface* transportInterface);

        GZ_REMOTE_EXPORT gzVoid setQueueLimit(gzUInt limit);        

    protected:

        // Virtual function from gzThread.
        gzVoid process();

    private:

        // Locker for m_transportList.
        gzMutex m_processLocker;

        // All transports.
        gzList<gzDistRouterTransport> m_transportList;
        
        // Message counter.
        gzULong m_messages;

        // Total number of routed bytes.
        gzULong m_routedBytes;

        // True while running.
        gzBool m_run;

        // Tells if the engine should route all messages
        // or only GizmoDistribution messages.
        gzBool m_routeGizmoDistOnly;

        gzDistProtocolMessageHeader m_messageHeader;

        gzUInt m_queueLimit;
};

#endif

---