gzDistSession.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistSession.h
// Module       : gzDistribution
// Description  : Definition of a gzDistributionSession
// 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  031021  Created file
//
//******************************************************************************
#ifndef __GZ_DIST_SESSION_H__
#define __GZ_DIST_SESSION_H__

// Includes
#include "gzDistBase.h"
#include "gzDistEvaluator.h"
#include "gzDistNotification.h"
#include "gzDistServer.h"

// Forward declarations
class gzDistSessionServer;
class gzDistSessionObjectIterator;
class gzDistSessionMessage;
class gzDistDebugClient;
class gzDistObjectAttribute;
class gzDistClientInterface;

enum gzDistEvaluatorPrio
{
    GZ_DIST_EVALUATOR_PRIO_LOWEST   = 1,    
    GZ_DIST_EVALUATOR_PRIO_LOW      = 3,    
    GZ_DIST_EVALUATOR_PRIO_MEDIUM   = 5,    
    GZ_DIST_EVALUATOR_PRIO_HIGH     = 7,    
    GZ_DIST_EVALUATOR_PRIO_HIGHEST  = 10    
};

//------------------------------- gzDistSession -------------------------------

//*****************************************************************************
// Class    : gzDistSession
//
// Purpose  : The base def class of a gzDistSession.
//
// Notes    : -
//
// Revision History...
//
// Who  Date    Description
//
// CAN  031021  Created 
//
//*****************************************************************************

class gzDistSession : public gzDistThreadSafeReference
{
    friend class gzDistManager;
    friend class gzDistSessionObjectIterator;
    friend class gzDistObject;

    public:

        GZ_DIST_EXPORT virtual ~gzDistSession();


        GZ_DIST_EXPORT const gzString& getName();


        GZ_DIST_EXPORT gzDistObjectPtr findObject(const gzString& name);


        GZ_DIST_EXPORT gzBool findObject(const gzString& name, gzDistObjectPtr& object);


        GZ_DIST_EXPORT gzBool isGlobal();


        GZ_DIST_EXPORT gzBool registerEvaluator(const gzDistEvaluatorInterfacePtr& evaluator, const gzDistEvaluatorPrio prio = GZ_DIST_EVALUATOR_PRIO_MEDIUM);


        GZ_DIST_EXPORT gzBool unregisterEvaluator(gzDistEvaluatorInterface* evaluator);

        /* \return  The number of objects in a session.*/
        GZ_DIST_EXPORT gzUInt getNumberOfObjects();


        GZ_DIST_EXPORT gzDistObjectPtr waitForObject(const gzString& objectName, gzInt timeOut = 10);


        GZ_DIST_EXPORT gzBool evaluate(gzDistObject* object, gzDistEvaluatorType type, gzDistTransaction* transaction = NULL);


        GZ_DIST_EXPORT gzDistObjectPtr getNextObject(gzDistObject* object, gzType* objectType);

    private:
    // None exported (Internal manager calls).

        // Constructor
        gzDistSession(gzDistManager* manager, const gzString& sessionName, gzBool global, gzDistServerPriority prio);

        // Subscribe an event type
        gzBool subscribeEvents(gzDistClientInterface* client, gzType* eventType);

        // Subscribe an object type
        gzBool subscribeObjects(gzDistClientInterface* client, gzType* objectType, const gzBool notifyExisting);

        // Unsubscribe an event type
        gzBool unsubscribeEvents(gzDistClientInterface* client, const gzType* eventType);

        // Unsubscribe an object type
        gzBool unsubscribeObjects(gzDistClientInterface* client, const gzType* objectType);

        // Subscribe on an attribute
        gzBool subscribeAttributeValue(const gzString& attributeName, gzDistObject* object, gzDistClientInterface* client, const gzBool notifyExisting);

        // Subscribe on attributes
        gzBool subscribeAttributeValue(gzDistTransaction* transaction, gzDistObject* object, gzDistClientInterface* client, const gzBool notifyExisting);

        // Unsubscribe on an attribute
        gzBool unsubscribeAttributeValue(const gzString& attributeName, gzDistObject* object, gzDistClientInterface* client);

        // Subscribe on new attributes
        gzBool subscribeNewAttributes(gzDistObject* object, gzDistClientInterface* client, const gzBool notifyExisting);

        // Unsubscribe on new attributes
        gzBool unsubscribeNewAttributes(gzDistObject* object, gzDistClientInterface* client);

        // Join session
        gzBool join(gzDistClientInterface* client);

        // Resign session.
        gzBool resign(gzDistClientInterface* client);
        
        // Process all session messages.
        gzBool process();

        // Process a gzDistSessionMessage.
        gzBool processSessionServerMessage(gzDistSessionMessage* message);

        // Release the manager and all objects.
        gzVoid shutDown();

        // Remove subscriptions if there are any lower than type.
        gzVoid removeLowerSubscriptions(gzDistClientInterface* client, gzType* type, gzDict<gzInstanceCompareInterface, gzList<gzDistClientInterface> >& subscribers);

        // Check if the client has a higher subscription than type.
        gzBool hasHigherSubscription(gzDistClientInterface* client, gzType* type, gzDict<gzInstanceCompareInterface, gzList<gzDistClientInterface> >& subscribers);

        // Notify client of all existing objects of current type in current session.
        gzVoid notifyExistingObjects(gzDistClientInterface* client, gzType* type);

        // Notify clients of event.
        gzVoid sendEvent(gzDistEvent* event, const gzDistClientID& clientId);

        // Do the insertion of the object to session and notify clients.
        gzBool addObject(gzDistObject* object, const gzDistClientID& clientId);

        // Update an object with data in transaction.
        gzBool updateObject(gzDistObject* object, gzDistTransaction* transaction, const gzDistClientID& clientId);

        // Do the remove of the object from session and notify clients.
        gzBool removeObject(gzDistObject* object, const gzDistClientID& clientId);

        // Remove attributes from an object.
        gzBool removeAttributes(gzDistTransaction* transaction, gzDistObject* object, const gzDistClientID& clientId);

        // Notify local clients of event.
        gzVoid localSendEvent(gzDistEvent* event, const gzDistClientID& clientId);

        // Do the insertion of the object to session and notify local clients.
        gzBool localAddObject(gzDistObject* object);

        // Update an object with data in transaction and notify local clients..
        gzBool localUpdateObject(gzDistObject* object, gzDistTransaction* transaction);
        
        // Do the remove of the attributes from object and notify local clients.
        gzBool localRemoveAttributes(gzDistTransaction* transaction, gzDistObject* object, const gzDistClientID& client);

        // Do the remove of the object from session and notify local clients.
        gzBool localRemoveObject(gzDistObject* object);

        // Request ownership on attribute and notify owner if the owner is localy joined.
        gzBool localRequestOwnership(gzDistObjectAttribute* attribute, const gzDistClientID& clientId);

        // Drop ownership/owner-request on attribute and notify client if the client is localy joined.
        // Next requesting client (if exist) will get the ownership.
        gzBool localDropOwnership(gzDistObjectAttribute* attribute, const gzDistClientID& clientId);

        // Finish current transaction to all clients.
        gzVoid endTransaction(const gzDistNotificationType type, gzDistObject* object);

        // Notify a client of ownership grant.
        gzVoid notifyGrantOwnership(gzDistObjectAttribute* attribute);

        // Notify a client of ownership drop.
        gzVoid notifyDropOwnership(gzDistObjectAttribute* attribute, gzDistClientInterface* client);

        // Notify all existing ownership requests for an attribute to a client.
        gzVoid notifyOwnersipRequests(gzDistObjectAttribute* attribute, gzDistClientInterface* client);

        // Get local client
        gzDistClientInterface* getClient(const gzDistClientID& clientId);

        // Returns the number of joined clients.
        gzUInt joinedClients();

        // Returns TRUE if the client is joined to session.
        gzBool isJoinedClient(const gzDistClientID& clientId);

        // Request ownership on attribute.
        gzBool requestOwnership(const gzString& attributeName, gzDistObject* object, gzDistClientInterface* client);

        // Drop ownership for attribute.
        gzBool dropOwnership(const gzString& attributeName, gzDistObject* object, gzDistClientInterface* client);

        // Take ownership on attribute by force.
        gzBool pullOwnership(const gzString& attributeName, gzDistObject* object, gzDistClientInterface* client);

        // Update/add object independent of owner etc.
        gzVoid synchronizeObject(gzDistObject* object);

        // Synchronize ownership for attribute
        gzVoid synchronizeOwnership(gzDistObjectAttribute* existingAttribute, gzDistObjectAttribute* syncAttribute);

        // Force an ownersip set.
        gzBool localSetOwnership(gzDistObjectAttribute* attribute, const gzDistClientID& clientId);

        // Validate an insertion of an object to session.
        gzBool isValidInsertion(gzDistObject* object);

        // Check if client is allowed to update the attributes in transaction.
        gzBool isAllowedUpdate(gzDistTransaction* transaction, gzDistObject* object, const gzDistClientID& clientId);

        // Clean up all ownership etc. referring to instance.
        gzVoid cleanUpInstance(const gzDistInstanceID& instance);

        // Check if the session has incoming or outgoing data at the moment. Either from clients or session server.
        gzBool hasPendingData();

        // Set debug client.
        gzVoid setDebugClient(gzDistDebugClient* debugClient);

        // Send attribute (value) subscribers to debugger.
        gzVoid debugAttributeSubscriptions(const gzString& attributeName, gzDistObject* object, gzDistClientInterface* subscriber, gzBool newClient);

        // Send attribute (value) subscribers to debugger.
        gzVoid debugAttributeSubscriptions(gzDistTransaction* transaction, gzDistObject* object, gzDistClientInterface* subscriber, gzBool newClient);

        // Send subscriptions on new/removed attributes to debugger.
        gzVoid debugNewAttributesSubscriptions(gzDistObject* object, gzDistClientInterface* subscriber, gzBool newClient);

        gzVoid debugOwnership(gzDistObjectAttribute* attribute);

        gzVoid addLinkObject(gzDistObject* object);

        gzVoid removeLinkObject(gzDistObject* object);

        gzDistObject* firstObject();

        gzBool isServer();

    // Private members

        // The name of the session.
        const gzString m_name;

        const gzDouble m_creationTime;

        // This list contains all subscribers of events. The key is a gzType*.
        gzDict<gzInstanceCompareInterface, gzList<gzDistClientInterface> > m_eventSubscribers;

        // This list contains all subscribers of objects. The key is a gzType*.
        gzDict<gzInstanceCompareInterface, gzList<gzDistClientInterface> > m_objectSubscribers;

        // This list contains all joined clients.
        gzDict<gzDistClientID, gzDistClientInterface> m_joinedClients;

        // All objects in session.
        gzRefDict<gzString, gzDistObject> m_objects;

        // Mutex for m_objects
        gzMutex m_objectsLocker;

        // Reference to current gzDistManager
        gzDistManagerPtr m_manager;

        // A list containing all evaluators for current session. The key is a gzType*.
        gzRefList<gzDistEvaluatorInterface> m_evaluators;

        // Thread mutex for m_evaluators
        gzMutex m_evaluatorLocker;

        // Pointer to current session manager.
        // If the pointer is NULL, the session is local.
        gzDistSessionServer* m_sessionServer;

        // Pointer to a list that will receive global messages from session server.
        gzList<gzDistSessionMessage>* m_sessionServerMessages;

        // Is non-zero if debug is enabled.
        gzDistDebugClient* m_debugClient;

        gzDistObject* m_firstObject;

        gzDistObject* m_lastObject;
};


//------------------------ gzDistSessionObjectIterator ------------------------

class gzDistSessionObjectIterator
{
    public:


        GZ_DIST_EXPORT gzDistSessionObjectIterator(const gzDistSessionPtr& session, gzType* objectType);


        GZ_DIST_EXPORT gzDistSessionObjectIterator(const gzDistSessionPtr& session);


        GZ_DIST_EXPORT ~gzDistSessionObjectIterator();


        GZ_DIST_EXPORT gzDistObject* operator()();

        GZ_DIST_EXPORT gzDistObject* current();

        GZ_DIST_EXPORT gzVoid reset();


        GZ_DIST_EXPORT gzVoid unLockSession();

    private:

        const gzDistSessionPtr m_session;
        gzDistObject* m_currentObject;
        gzType* m_objectType;
        gzBool m_lockedSession;
};

//------------------------ gzDistSessionIterator ------------------------

class gzDistSessionIterator
{
    public:
        GZ_DIST_EXPORT gzDistSessionIterator();
        GZ_DIST_EXPORT ~gzDistSessionIterator();


        GZ_DIST_EXPORT gzDistSession* operator()();

        GZ_DIST_EXPORT gzDistSession* current();

        GZ_DIST_EXPORT gzVoid reset();

    private:

        gzDistManagerPtr m_manager;

        gzDictIterator<gzString, gzDistSession>* m_iterator;
        gzDictEntry<gzString, gzDistSession>* m_entry;
        
        gzBool m_sessionsLocked;
};

#endif //__GZ_DIST_SESSION_H__

---