gzDistBase.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistBase.h
// Module       : gzDistribution
// Description  : Definition of basic types
// Author       : Anders Sandblad, 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
//
// XAA  031021  Created file
//
//******************************************************************************
#ifndef __GZ_DIST_BASE_H__
#define __GZ_DIST_BASE_H__

// Some basic includes
#include "gzBaseLibrary.h"  

#ifdef GZ_WIN32
    #include <assert.h>     
#endif


//-------------------------- Common definitions -------------------------------

#ifdef GZ_WIN32
    #ifndef GZ_DIST_STATIC      
        #define GZ_DIST_DLL     
    #endif
#endif 

#ifdef GZ_DIST_DLL  

    #ifdef GZ_DISTRIBUTION_EXPORTS                      
        #define GZ_DIST_EXPORT  __declspec(dllexport)   
    #else
        #define GZ_DIST_EXPORT  __declspec(dllimport)   
    #endif

    #ifdef GZ_REMOTE_DISTRIBUTION_EXPORTS                   
        #define GZ_REMOTE_EXPORT    __declspec(dllexport)   
    #else
        #define GZ_REMOTE_EXPORT    __declspec(dllimport)   
    #endif

#else

    #define GZ_DIST_EXPORT      
    #define GZ_REMOTE_EXPORT    

#endif


//-------------------- Debugging and error reporting --------------------------

const gzString GZ_DIST_IDENTIFIER = "GizmoDistribution";

#define GZ_DIST_ASSERT(expr)            GZ_MODULE_ASSERT(GZ_DIST_IDENTIFIER, expr)              
#define GZ_DIST_ASSERT_TEXT(expr, text) GZ_MODULE_ASSERT_TEXT(GZ_DIST_IDENTIFIER, expr, text)   

#define GZ_DIST_DEBUG   GZ_DIST_IDENTIFIER, GZ_MESSAGE_DEBUG    
#define GZ_DIST_NOTICE  GZ_DIST_IDENTIFIER, GZ_MESSAGE_NOTICE   
#define GZ_DIST_WARNING GZ_DIST_IDENTIFIER, GZ_MESSAGE_WARNING  
#define GZ_DIST_FATAL   GZ_DIST_IDENTIFIER, GZ_MESSAGE_FATAL    

// GZ_DIST_DEBUG_WARNING is a warning level at debug mode, and debug level at non debug mode.
#ifdef GZ_DEBUG
    #define GZ_DIST_DEBUG_WARNING   GZ_DIST_WARNING     
#else
    #define GZ_DIST_DEBUG_WARNING   GZ_MESSAGE_DEBUG    
#endif

#define GZ_DIST_TRACE0(text)    GZTRACES(GZ_DIST_IDENTIFIER, text)                                          
#define GZ_DIST_TRACE1(format, arg1)    GZTRACES(GZ_DIST_IDENTIFIER, format, arg1)                          
#define GZ_DIST_TRACE2(format, arg1, arg2)  GZTRACES(GZ_DIST_IDENTIFIER, format, arg1, arg2)                
#define GZ_DIST_TRACE3(format, arg1, arg2, arg3)    GZTRACES(GZ_DIST_IDENTIFIER, format, arg1, arg2, arg3)  


//----------------------- Memory performance optimizing -----------------------

// Define this for activation of GZ_MEMBASE optimization in GizmoDistribution
#define GZ_DIST_OPTIMIZED_MEMORY

#ifdef GZ_DIST_OPTIMIZED_MEMORY
    #define GZ_DIST_DECLARE_MEMBASE(cls)                GZ_DECLARE_MEMBASE(cls)
    #define GZ_DIST_DECLARE_MEMBASE_EXPORT(cls, exp)    GZ_DECLARE_MEMBASE_EXPORT(cls, exp)
    #define GZ_DIST_MEMBASE(cls)                        , public GZ_MEMBASE(cls)
    #define GZ_DIST_MEMBASE_SINGLE(cls)                 : public GZ_MEMBASE(cls)
    #define GZ_DIST_MEMBASE_IMP(cls)                    GZ_MEMBASE_IMP(cls)
    #define GZ_DIST_DECLARE_MEMBASE_IMP(cls, size)      GZ_DECLARE_MEMBASE_IMP(cls, size)

    #define GZ_DIST_MEMBASE_CALL(className)                                                                 \
        static gzVoid enableOptimizeMemory() { s_allocator_##className.enable(); }                          \
        static gzVoid disableOptimizeMemory(gzBool force = FALSE) { s_allocator_##className.disable(); }    \
        static gzBool tryResizeOptimizeMemory(gzULong nbrOfslots) { return s_allocator_##className.tryResize(nbrOfslots); }
#else
    #define GZ_DIST_DECLARE_MEMBASE(cls)
    #define GZ_DIST_DECLARE_MEMBASE_EXPORT(cls, exp)
    #define GZ_DIST_MEMBASE(cls)
    #define GZ_DIST_MEMBASE_SINGLE(cls)
    #define GZ_DIST_MEMBASE_IMP(cls)
    #define GZ_DIST_DECLARE_MEMBASE_IMP(cls, size)

    #define GZ_DIST_MEMBASE_CALL(className)
#endif



//---------------------------- Common constants -------------------------------

const gzString GZ_DIST_EVENT        = gzUniqueString("gzDistEvent", 90);

const gzString GZ_DIST_OBJECT       = gzUniqueString("gzDistObject", 91);

const gzString GZ_DIST_NO_NAME;


//---------------------------- Timeout constants ------------------------------

const gzInt GZ_DIST_SYNCHRONOUS = -1;

const gzInt GZ_DIST_ASYNCHRONOUS = 0;

const gzULong GZ_DIST_IDLE_SLEEP_TIME = 10;


//----------------------------- Thread pool IDs -------------------------------

const gzULong GZ_DIST_POOL_ID_DEFAULT = 0;

const gzULong GZ_DIST_POOL_ID_CUSTOM = 0xFFFFFFFF;

const gzULong GZ_DIST_POOL_ID_DEBUG = 0xDEBA6;


//--------------------------- Network constants -------------------------------

const gzString GZ_DIST_DEFAULT_IP_ADDRESS   = "234.5.6.7";

const gzUShort GZ_DIST_DEFAULT_SERVER_PORT  = 1122;

const gzUShort GZ_DIST_DEFAULT_SESSION_PORT = 2211;


//---------------------- Common type definitions  -----------------------------

#define GZ_DIST_PTR(x)  class x; typedef gzRefPointer<x> x##Ptr

#define GZ_DIST_LIST(x) typedef gzRefList<x> x##List; \
                        typedef gzListIterator<x> x##Iterator



//------------- Declaration of thread safe reference pointers -----------------

GZ_DIST_PTR(gzDistThreadSafeReference); 
GZ_DIST_PTR(gzDistEvent);               
GZ_DIST_PTR(gzDistObject);              
GZ_DIST_PTR(gzDistTransaction);         
GZ_DIST_PTR(gzDistSession);             
GZ_DIST_PTR(gzDistManager);             
GZ_DIST_PTR(gzDistManagerMessage);      
GZ_DIST_PTR(gzDistClientMessage);       
GZ_DIST_PTR(gzDistNotification);        
GZ_DIST_PTR(gzDistNotificationData);    
GZ_DIST_PTR(gzDistEvaluatorInterface);  
GZ_DIST_PTR(gzDistRemoteMessage);       
GZ_DIST_PTR(gzDistRouterBuffer);        


//-------------------- Declaration of lists and iterators ---------------------

GZ_DIST_LIST(gzDistClientMessage);
GZ_DIST_LIST(gzDistManagerMessage);
GZ_DIST_LIST(gzDistNotification);


//-------------------- gzDistThreadSafeReference ------------------------------

class gzDistThreadSafeReference : public gzReference
{
    public:

        GZ_DIST_EXPORT gzDistThreadSafeReference();

        GZ_DIST_EXPORT virtual ~gzDistThreadSafeReference();

        GZ_DIST_EXPORT gzVoid ref();

        GZ_DIST_EXPORT gzVoid unref();

        GZ_DIST_EXPORT gzUInt unrefNoDelete();

        GZ_DIST_EXPORT virtual gzReference* clone() const;

        GZ_DIST_EXPORT virtual gzBool useDeepCopy();

        
    private:

        gzMutex m_referenceLocker;
};

//----------------------- gzDistTrigger ------------------------

class gzDistTrigger
{
    public:
        gzDistTrigger();
        ~gzDistTrigger();

        gzBool isTrigged() const;
        gzVoid reset();
        gzVoid fire();

        // Return TRUE if trigged.
        gzBool wait(gzUInt timeOut);

    private:
        gzEvent m_trigger;
        gzBool m_trigged;
};

//----------------------- gzDistRemoteChannelInterface ------------------------

// Forward declarations
class gzDistTransportInterface;
class gzDistEncoderInterface;


class gzDistRemoteChannelInterface
{
    public:

        GZ_DIST_EXPORT gzDistRemoteChannelInterface() { };
        
        // Destructor
        GZ_DIST_EXPORT virtual ~gzDistRemoteChannelInterface() { };


        GZ_REMOTE_EXPORT virtual gzBool setTransport(gzDistTransportInterface* transport, gzDistEncoderInterface* encoder = NULL) = 0;

        GZ_DIST_EXPORT virtual gzBool open() = 0;
        
        GZ_DIST_EXPORT virtual gzVoid close() = 0;
        
        GZ_DIST_EXPORT virtual gzBool isOpen() = 0;

        GZ_DIST_EXPORT virtual gzBool send(gzDistRemoteMessage* message) = 0;

        GZ_DIST_EXPORT virtual gzBool receive(gzDistRemoteMessagePtr& message) = 0;

        GZ_DIST_EXPORT virtual gzUInt getProtocolHeaderSize() = 0;

        GZ_DIST_EXPORT virtual gzVoid onTick(){}

        GZ_DIST_EXPORT virtual gzBool hasPendingData(){return FALSE;}
};


//----------------------------- gzDistInstanceID --------------------------------


class GZ_DIST_EXPORT gzDistInstanceID
{
    public:
    
        gzDistInstanceID();

        gzDistInstanceID(gzULong pid, gzULong mid);

        gzDistInstanceID(gzULongLong id);

        virtual ~gzDistInstanceID();
    
        gzBool operator==(const gzDistInstanceID& id) const;

        gzBool operator!=(const gzDistInstanceID& id) const;

        gzBool operator<(const gzDistInstanceID& id) const;
        
        gzBool operator>(const gzDistInstanceID& id) const;

        gzBool isNull() const;

        gzVoid setNull();
        
        gzString asString() const;

        gzULongLong asULongLong() const;

        gzULong processID;
        
        gzULong machineID;
    
};


const gzDistInstanceID GZ_DIST_NULL_INSTANCE(0, 0);


//----------------------------- gzDistClientID --------------------------------


class GZ_DIST_EXPORT gzDistClientID
{
    public:
        
        gzDistClientID();
        

        explicit gzDistClientID(const gzString& name);

        gzDistClientID(const gzString& name, const gzDistInstanceID& instance);

        gzDistClientID(const gzString& name, gzUInt pid, const gzULong mid);

        ~gzDistClientID();

        gzBool operator==(const gzDistClientID& id) const;

        gzBool operator!=(const gzDistClientID& id) const;
        
        gzBool isNull() const;

        gzVoid setNull();

        gzString asString() const;

        gzULong hash() const;

    // Data

        gzString name;
        
        gzDistInstanceID instanceID;        
};


const gzDistClientID GZ_DIST_NULL_CLIENT(GZ_EMPTY_STRING, GZ_DIST_NULL_INSTANCE);


//---------------------------- Common functions -------------------------------
// --- Internals ---
class gzDistInternals
{
    friend class gzDistRemoteChannel;
    friend class gzDistServerImpl;
    friend class gzDistManager;

    private:
        GZ_DIST_EXPORT static gzVoid gzDistAddPendingInstance(const gzDistInstanceID& instanceId);
        GZ_DIST_EXPORT static gzBool gzDistProcessPendingInstance(const gzDistInstanceID& instanceId, gzVoid* channel);
        GZ_DIST_EXPORT static gzVoid gzDistClearPendingInstances();
};

// --- Publics ---


GZ_DIST_EXPORT gzUInt gzDistGetCurrentProcessID();



GZ_DIST_EXPORT gzULong gzDistGetCurrentMachineID();



GZ_DIST_EXPORT const gzDistInstanceID& gzDistGetCurrentInstanceID();

#endif //__GZ_DIST_BASE_H__

---