gzNode.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzNode.h
// Module       : 
// Description  : Class definition of the gzNode class
// Author       : Anders Modén      
// Product      : Gizmo3D 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    Gizmo3D is a high performance 3D Scene Graph and effect visualisation 
//          C++ toolkit for Linux, Mac OS X, Windows (Win32) and IRIX® for  
//          usage in Game or VisSim development.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981014  Created file    
//
//******************************************************************************
#ifndef __GZ_NODE_H__
#define __GZ_NODE_H__

#include "gzObject.h"
#include "gzMatrix.h"
#include "gzState.h"
#include "gzDbFlags.h"

class gzContext;    // Forward decl
class gzNode;       // Forward declaraton


// Additional Node gzDebugFlags
const gzDebugFlags GZ_DEBUG_RECURSIVE           =(gzDebugFlags)(1<<0);
const gzDebugFlags GZ_DEBUG_SHOW_ATTRIBUTES     =(gzDebugFlags)(1<<1);
const gzDebugFlags GZ_DEBUG_SHOW_GEOMETRY       =(gzDebugFlags)(1<<2);
const gzDebugFlags GZ_DEBUG_SHOW_USERDATA       =(gzDebugFlags)(1<<3);
const gzDebugFlags GZ_DEBUG_SHOW_STATE          =(gzDebugFlags)(1<<4);
const gzDebugFlags GZ_DEBUG_SHOW_NODE_ACTIONS   =(gzDebugFlags)(1<<5);


enum gzIntersectMaskValue
{   
    GZ_INTERSECT_MASK_GROUND            =   (1<<1)  ,

    GZ_INTERSECT_MASK_WATER             =   (1<<2)  ,

    GZ_INTERSECT_MASK_MAP_SURFACE       =   GZ_INTERSECT_MASK_GROUND | GZ_INTERSECT_MASK_WATER ,


    GZ_INTERSECT_MASK_BUILDING          =   (1<<3)  ,

    GZ_INTERSECT_MASK_FOREST            =   (1<<4)  ,

    GZ_INTERSECT_MASK_STATIC_OBJECT     =   GZ_INTERSECT_MASK_FOREST | GZ_INTERSECT_MASK_BUILDING   ,


    GZ_INTERSECT_MASK_HUMAN             =   (1<<5)  ,
    
    GZ_INTERSECT_MASK_ANIMAL            =   (1<<6)  ,

    GZ_INTERSECT_MASK_VEHICLE           =   (1<<7)  ,

    GZ_INTERSECT_MASK_DYNAMIC_OBJECT    =   GZ_INTERSECT_MASK_HUMAN | GZ_INTERSECT_MASK_ANIMAL  ,


    GZ_INTERSECT_MASK_OVERLAY_OBJECTS   =   (1<<8)  ,

    GZ_INTERSECT_MASK_UNDERLAY_OBJECTS  =   (1<<9)  ,

    GZ_INTERSECT_MASK_SCREEN_OBJECT =   GZ_INTERSECT_MASK_OVERLAY_OBJECTS | GZ_INTERSECT_MASK_UNDERLAY_OBJECTS  ,

    GZ_INTERSECT_MASK_ALL               =   -1      ,

    GZ_INTERSECT_MASK_NOTHING           =   0   
};

GZ_USE_BIT_LOGIC(gzIntersectMaskValue);

enum gzCullMaskValue
{   
    GZ_CULL_MASK_ALL            =   -1,
    GZ_CULL_MASK_NOTHING        =   0   
};

GZ_USE_BIT_LOGIC(gzCullMaskValue);

//************** Common defined performance sections ******************

const gzString GZ_SECTION_RENDER                ="_render";
const gzString GZ_SECTION_CULL                  ="_cull";
const gzString GZ_SECTION_NODE_DATA             ="_node_upd";
const gzString GZ_SECTION_DYNLOAD               ="_dynload";
const gzString GZ_SECTION_REFRESH               ="_refresh";
const gzString GZ_SECTION_FINISH                ="_finish";
const gzString GZ_SECTION_SHADOW_VOLUME_CREATE  ="_shad_vol_cr";
const gzString GZ_SECTION_SHADOW_VOLUME_RENDER  ="_shad_vol_re";

//******************************************************************************
// Class    : gzIntersectMask
//                                  
// Purpose  : To keep a definition of what kind of intersect object it is.
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000828  Created 
//                                  
//******************************************************************************
class GZ_GRAPH_EXPORT gzIntersectMask
{
public:

    inline gzIntersectMask():m_mask(GZ_INTERSECT_MASK_ALL){}

    inline virtual ~gzIntersectMask(){}

    inline gzVoid setIntersectMask( const gzIntersectMaskValue & mask )
    {
        m_mask=mask;
    }

    inline gzIntersectMaskValue getIntersectMask()
    {
        return m_mask;
    }

    inline gzBool isIntersecting( const gzIntersectMaskValue & mask )
    {
        return (mask&m_mask)!=0;
    }

    inline gzBool isIntersecting( gzIntersectMask * imask )
    {
        return (m_mask&imask->m_mask)!=0;
    }

private:

    gzIntersectMaskValue    m_mask;
};

//******************************************************************************
// Class    : gzCullMask
//                                  
// Purpose  : To keep a definition of what shall be culled or not
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  050209  Created 
//                                  
//******************************************************************************
class GZ_GRAPH_EXPORT gzCullMask
{
public:

    inline gzCullMask():m_mask(GZ_CULL_MASK_NOTHING){}

    inline virtual ~gzCullMask(){}

    inline gzVoid setCullMask( const gzCullMaskValue & mask )
    {
        m_mask=mask;
    }

    inline gzCullMaskValue getCullMask()
    {
        return m_mask;
    }

    inline gzBool isCulled( const gzCullMaskValue & mask )
    {
        return (mask&m_mask)!=0;
    }

    inline gzBool isCulled( gzCullMask * mask )
    {
        return (m_mask&mask->m_mask)!=0;
    }

private:

    gzCullMaskValue m_mask;
};


const gzCopyMode    GZ_CLONE_SHARE_STATE        = (gzCopyMode)(1<<0); 
const gzCopyMode    GZ_CLONE_SHARE_GEOMETRY     = (gzCopyMode)(1<<1);
const gzCopyMode    GZ_CLONE_SHARE_TEXTURE      = (gzCopyMode)(1<<2);
const gzCopyMode    GZ_CLONE_SHARE_MATERIAL     = (gzCopyMode)(1<<3);
const gzCopyMode    GZ_CLONE_SHARE_TEXENV       = (gzCopyMode)(1<<4);
const gzCopyMode    GZ_CLONE_SHARE_TEXGEN       = (gzCopyMode)(1<<5);
const gzCopyMode    GZ_CLONE_SHARE_GFX_PROGRAM  = (gzCopyMode)(1<<6);
const gzCopyMode    GZ_CLONE_SHARE_FONT         = (gzCopyMode)(1<<7);

//******************************************************************************
// Class    : gzNodeLock
//                                  
// Purpose  : To lock scene graph nodes between rendering and editing threads
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  991123  Created 
//                                  
//******************************************************************************

class GZ_GRAPH_EXPORT gzNodeLock
{
public:

    static gzVoid waitLockRender();

    static gzVoid waitLockEdit();

    static gzBool tryLockRender();

    static gzBool tryLockEdit();

    static gzVoid unLock();

    static gzBool isLocked();

    static gzBool isLockedRender();

    static gzBool isLockedEdit();

    static gzULong getLockedEditThreadID();

private:

    static gzSemaphore g_lock;
};



//******************************************************************************
// Class    : gzTraverseAction
//                                  
// Purpose  : To traverse a graph of nodes
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981126  Created 
//                                  
//******************************************************************************
class gzTraverseAction : public gzTypeInterface
{
public:

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface

    GZ_GRAPH_EXPORT gzVoid traverse(gzNode *node,gzContext *context);

    GZ_GRAPH_EXPORT virtual gzBool traverseTransform(){ return TRUE; }

protected:

    GZ_GRAPH_EXPORT virtual gzBool checkBoundary(gzContext *context, gzNode *node) { return TRUE; } // default TRUE

    GZ_GRAPH_EXPORT virtual gzVoid preTraverseAction( gzNode *node , gzContext *context);
    GZ_GRAPH_EXPORT virtual gzVoid postTraverseAction( gzNode *node , gzContext *context);
};

enum gzBoundaryMode
{
    GZ_BOUNDARY_DEFAULT,
    GZ_BOUNDARY_ZERO_Y
};
    
//******************************************************************************
// Class    : gzBoundary
//                                  
// Purpose  : -
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981202  Created 
//                                  
//******************************************************************************
class gzBoundary
{
public:

    GZ_GRAPH_EXPORT gzBoundary():   m_center(gzVec3(0,0,0)),m_baseOffset(0),m_radius(0.0f),m_mode(GZ_BOUNDARY_DEFAULT),m_accumIncludeBoundary(FALSE),
                                    m_recursiveIncludeBoundary(FALSE),m_childRecursiveIncludeBoundary(FALSE),m_isReset(TRUE),m_localIncludeBoundary(FALSE),m_useRadius(TRUE){}

    GZ_GRAPH_EXPORT virtual ~gzBoundary(){};

    GZ_GRAPH_EXPORT const  gzVec3 & getBoundaryCenter() const   { return m_center; }
    GZ_GRAPH_EXPORT const  gzReal & getBoundaryRadius() const   { return m_radius; }

    GZ_GRAPH_EXPORT gzVoid setBoundaryCenter( gzVec3 center );

    GZ_GRAPH_EXPORT gzVoid setBoundaryRadius( gzReal radius );

    GZ_GRAPH_EXPORT gzVoid resetBoundary()                      { m_isReset = TRUE ; m_radius=GZ_FLOAT_ZERO; m_center=gzVec3(0,0,0); m_childRecursiveIncludeBoundary=FALSE; m_accumIncludeBoundary=m_recursiveIncludeBoundary|m_localIncludeBoundary; }

    GZ_GRAPH_EXPORT gzVoid unResetBoundary()                    { m_isReset = FALSE;  }

    GZ_GRAPH_EXPORT gzVoid includeBoundary(const gzVec3 &center , const gzReal &radius );

    GZ_GRAPH_EXPORT gzVoid includeMaxBoundary(const gzVec3 &center , const gzReal &radius , const gzVec3 &offset=gzVec3(0,0,0));

    GZ_GRAPH_EXPORT gzVoid includeBoundary(const gzBoundary *boundary , gzMatrix4 *transform , gzReal maxScale);

    GZ_GRAPH_EXPORT gzVoid includeMaxBoundary(const gzBoundary *boundary , gzMatrix4 *transform, gzReal maxScale , const gzVec3 &offset=gzVec3(0,0,0));


    GZ_GRAPH_EXPORT inline gzBool getRecursiveIncludeBoundary() const           { return m_recursiveIncludeBoundary|m_childRecursiveIncludeBoundary; }

    GZ_GRAPH_EXPORT inline gzBool getForceRecursiveIncludeBoundary() const      { return m_recursiveIncludeBoundary; }

    GZ_GRAPH_EXPORT inline gzBool getForceChildRecursiveIncludeBoundary() const { return m_childRecursiveIncludeBoundary; }

    GZ_GRAPH_EXPORT inline gzBool getForceLocalIncludeBoundary() const          { return m_localIncludeBoundary; }

    GZ_GRAPH_EXPORT inline gzBool getForceIncludeBoundary() const               { return m_accumIncludeBoundary; }

    GZ_GRAPH_EXPORT gzVoid setForceRecursiveIncludeBoundary(gzBool on)          { m_recursiveIncludeBoundary=on; m_accumIncludeBoundary=m_recursiveIncludeBoundary|m_childRecursiveIncludeBoundary|m_localIncludeBoundary; }

    GZ_GRAPH_EXPORT gzVoid setForceChildRecursiveIncludeBoundary(gzBool on)     { m_childRecursiveIncludeBoundary=on; m_accumIncludeBoundary=m_recursiveIncludeBoundary|m_childRecursiveIncludeBoundary|m_localIncludeBoundary; }

    GZ_GRAPH_EXPORT gzVoid setForceLocalIncludeBoundary(gzBool on)              { m_localIncludeBoundary = on; m_accumIncludeBoundary=m_recursiveIncludeBoundary|m_childRecursiveIncludeBoundary|m_localIncludeBoundary; }


    GZ_GRAPH_EXPORT gzVoid setBaseOffsetBoundary(gzReal offset)                 { m_baseOffset=offset; }

    GZ_GRAPH_EXPORT gzReal getBaseOffsetBoundary()                              { return m_baseOffset; }

    GZ_GRAPH_EXPORT gzVoid setBoundaryMode(gzBoundaryMode mode)                 { m_mode=mode; }

    GZ_GRAPH_EXPORT gzVoid adjustBoundary();

    // --------- set to false if object doesn't have a radius -----

    GZ_GRAPH_EXPORT gzVoid useRadius(gzBool on)                                 { m_useRadius=on; }

    GZ_GRAPH_EXPORT inline gzBool useRadius() const                             { return m_useRadius; }


private:

    gzVec3          m_center;
    gzReal          m_baseOffset;
    gzReal          m_radius;
    
    gzBoundaryMode  m_mode;
                    
    gzBool          m_accumIncludeBoundary:1;
    gzBool          m_recursiveIncludeBoundary:1;
    gzBool          m_childRecursiveIncludeBoundary:1;
    gzBool          m_isReset:1;
    gzBool          m_localIncludeBoundary:1;
    gzBool          m_useRadius:1;
};

 enum gzNodeActionEvent
 {  
    // Subscribeable options
    GZ_NODE_ACTION_BEFORE_PRE_TRAVERSE  = 0         , 
    GZ_NODE_ACTION_AFTER_PRE_TRAVERSE               ,
    GZ_NODE_ACTION_BEFORE_POST_TRAVERSE             ,
    GZ_NODE_ACTION_AFTER_POST_TRAVERSE              ,
    GZ_NODE_ACTION_BEFORE_RENDER                    ,
    GZ_NODE_ACTION_AFTER_RENDER                     ,

    GZ_NODE_ACTION_BEFORE_SCENE_RENDER              ,
    GZ_NODE_ACTION_AFTER_SCENE_RENDER               ,

    GZ_NODE_ACTION_BEFORE_SCENE_UPDATE_NODE_DATA    ,
    GZ_NODE_ACTION_AFTER_SCENE_UPDATE_NODE_DATA     ,

    GZ_NODE_ACTION_BEFORE_NODE_DATA_UPDATE          ,
    GZ_NODE_ACTION_AFTER_NODE_DATA_UPDATE           ,

    GZ_NODE_ACTION_REF                              ,
    GZ_NODE_ACTION_UNREF                            ,
    GZ_NODE_ACTION_NODE_ID_CHANGE                   ,


    // Internal action , no use
    GZ_NODE_ACTION_COUNT                    ,

    // Default Actions, always active
    GZ_NODE_ACTION_ADD                      ,
    GZ_NODE_ACTION_REMOVE               
};

class gzNodeActionInterface;    // Forward

//******************************************************************************
// Class    : gzNodeActionInterfaceHandle
//                                  
// Purpose  : Holds data of active actions combined with user data
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class gzNodeActionInterfaceHandle
{
public:

    gzRefPointer<gzNodeActionInterface> receiver;
    gzVoid                              *userdata;
};

//******************************************************************************
// Class    : gzNodeActionProvider
//                                  
// Purpose  : The node action provider
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class gzNodeActionProvider : public gzObject
{
public:

    GZ_GRAPH_EXPORT gzNodeActionProvider();

    GZ_GRAPH_EXPORT virtual ~gzNodeActionProvider();

    GZ_GRAPH_EXPORT gzNodeActionProvider(const gzNodeActionProvider & copy);

    GZ_GRAPH_EXPORT gzNodeActionProvider &operator=(const gzNodeActionProvider & copy);

    GZ_GRAPH_EXPORT virtual gzVoid  ref();      // Ref/Unref detection
    GZ_GRAPH_EXPORT virtual gzVoid  unref();

    // ---------- Node action interface --------------------------------

    GZ_GRAPH_EXPORT gzVoid action(gzNodeActionEvent action , gzContext *context ,gzTraverseAction *actionclass);

    GZ_GRAPH_EXPORT gzBool  hasActiveActions()  { return m_receivers!=NULL; }

    GZ_GRAPH_EXPORT gzBool  hasActiveAction(gzNodeActionEvent action);

    GZ_GRAPH_EXPORT gzVoid addActionInterface(gzNodeActionInterface *receiver , gzNodeActionEvent action , gzVoid *userdata=NULL);
    GZ_GRAPH_EXPORT gzVoid removeActionInterface(gzNodeActionInterface *receiver , gzNodeActionEvent action );
    GZ_GRAPH_EXPORT gzVoid removeAllActionInterfaces(gzType *type=NULL);
    GZ_GRAPH_EXPORT gzBool hasActionInterfaceType(gzType *type);

    GZ_GRAPH_EXPORT gzArray<gzNodeActionInterfaceHandle> getActionInterfaces(gzNodeActionEvent action);

    


    // ---------- Debug function ----------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid  debugOutput(gzString base , gzString anchor , gzDebugFlags features);


private:

    gzList<gzNodeActionInterfaceHandle> *m_receivers;
};

//******************************************************************************
// Class    : gzNodeActionInterface
//                                  
// Purpose  : Derive from this interface to get node actions
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class gzNodeActionInterface : public gzReference
{
public:

    GZ_GRAPH_EXPORT gzNodeActionInterface():m_activeProviders(NULL){};

    GZ_GRAPH_EXPORT gzNodeActionInterface(const gzNodeActionInterface &copy);

    GZ_GRAPH_EXPORT gzNodeActionInterface & operator=(const gzNodeActionInterface &copy);

    GZ_GRAPH_EXPORT virtual ~gzNodeActionInterface();

    GZ_GRAPH_EXPORT virtual gzVoid onAction(gzNodeActionEvent action , gzContext *context , gzNodeActionProvider *trigger , gzTraverseAction *actionclass , gzVoid *userdata){};

    GZ_GRAPH_EXPORT gzList<gzNodeActionProvider>    * getActionProviderInterfaces();

    GZ_GRAPH_EXPORT gzVoid removeAllActions();

private:

    friend class gzNodeActionProvider;

    gzList<gzNodeActionProvider>    *m_activeProviders;
};


// Forward declaration of a group
class gzGroup;

// Disable clear and destroy for gzGroup
template <> inline gzVoid gzList<gzGroup>::clearAndDestroy() 
{
}

//******************************************************************************
// Class    : gzNode
//                                  
// Purpose  : -
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980912  Created 
//                                  
//******************************************************************************
class gzNode :  public gzBoundary , public gzNodeActionProvider , 
                public gzNameInterface , public gzDebugInterface , 
                public gzIntersectMask , public gzUpdateIDInterface , 
                public gzCullMask
{
public:

    GZ_GRAPH_EXPORT gzNode(const gzString & name=GZ_EMPTY_STRING);
    GZ_GRAPH_EXPORT virtual ~gzNode();

    GZ_GRAPH_EXPORT gzNode(const gzNode &copy);
    GZ_GRAPH_EXPORT gzNode & operator=(const gzNode &copy);


    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface

    // ---------- Clone interface ---------------------------------------
    GZ_GRAPH_EXPORT virtual gzReference* clone() const;
    GZ_GRAPH_EXPORT virtual gzVoid  setCopyMode(gzCopyMode mode);
    GZ_GRAPH_EXPORT virtual gzBool  useDeepCopy();

    // ---------- Action Interface --------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid preTraverseAction( gzTraverseAction *actionclass , gzContext *context) {};
    GZ_GRAPH_EXPORT virtual gzVoid postTraverseAction( gzTraverseAction *actionclass , gzContext *context) {};
    GZ_GRAPH_EXPORT virtual gzActionStage useActionStage( gzTraverseAction *actionclass , gzContext *context) { return GZ_ACTION_STAGE_TRAVERSE; }
    GZ_GRAPH_EXPORT virtual gzBool isGroupNode() { return FALSE; }  // Speed up RTTI

    // ---------- Common graph functions --------------------------------

    GZ_GRAPH_EXPORT gzVoid  setState( gzState *state );
    GZ_GRAPH_EXPORT gzState *getState();

    GZ_GRAPH_EXPORT virtual gzNode *find(const gzString &path,gzBool recursive=TRUE);

    // ----------- Parent Utilities --------------------------------------

    GZ_GRAPH_EXPORT gzVoid              removeFromParents();
    GZ_GRAPH_EXPORT gzList<gzGroup> &   getParentGroupList();
    GZ_GRAPH_EXPORT gzULong             getNumberOfParents();   
    GZ_GRAPH_EXPORT gzBool              isShared();
    GZ_GRAPH_EXPORT gzBool              isHierarchicalChildOf(gzGroup *group);

    // ---------- Debug function ----------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid  debugOutput(gzString base , gzString anchor , gzDebugFlags features);

    // ---------- Serializing -------------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter);
    GZ_GRAPH_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter);
    GZ_GRAPH_EXPORT virtual gzULong getDataSize(gzSerializeAdapter *adapter) const;


    // ---------- Node identities ---------------------------------------

    GZ_GRAPH_EXPORT gzBool  registerNodeID(gzULong id);
    GZ_GRAPH_EXPORT gzBool  unregisterNodeID();
    GZ_GRAPH_EXPORT gzBool  getNodeId(gzULong &id);
    static GZ_GRAPH_EXPORT  gzNode *findNode(gzULong id);
    static GZ_GRAPH_EXPORT  gzULong getMaxUsedNodeId();
    static GZ_GRAPH_EXPORT  gzVoid preAllocateNodeId(gzULong id);
    
    // ---------- Boundary management -----------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid updateNode() {};

    GZ_GRAPH_EXPORT virtual gzVoid updateNodeData(gzBool forceBoundaryUpdate=FALSE);

    GZ_GRAPH_EXPORT gzVoid setDirtyNodeData(gzBool dirty);      
    GZ_GRAPH_EXPORT gzBool hasDirtyNodeData();
    GZ_GRAPH_EXPORT gzVoid enableNodeDataUpdate(gzBool on);     // Update data in a node
    GZ_GRAPH_EXPORT gzBool doUpdateNodeData();

protected:

    // ---------- Protected Boundary management -----------------------------------

    friend class gzGroup;

    GZ_GRAPH_EXPORT gzVoid addParentGroup(gzGroup *parent);
    GZ_GRAPH_EXPORT gzVoid removeParentGroup(gzGroup *parent);

private:

    gzBool  getNodeId_unsafe(gzULong &id);

    // ---------- common node members -----------------------------------

    gzRefPointer<gzState> m_state;

    // Boundary Group info

    gzList<gzGroup>     m_parents;
    gzULong             m_nodeID;
    gzUByte             m_dirtyNodeData:1;
    gzUByte             m_updateNodeData:1;

    // Static vars

    static gzMutex                                      nodeIdLocker;
    static gzDict<gzULongCompareInterface,gzNode>       nodeIdStorage;
    static gzDict<gzInstanceCompareInterface,gzVoid>    idNodeStorage;

};

// Declare smart pointer type
GZ_DECLARE_REFPTR(gzNode);

//******************************************************************************
// Class    : gzDbManager
//                                  
// Purpose  : -
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980912  Created 
//                                  
//******************************************************************************
class gzDbManager : public gzReference
{
public:

    GZ_GRAPH_EXPORT virtual ~gzDbManager(){};

    GZ_GRAPH_EXPORT static gzVoid   registerManager(gzDbManager *manager);

    GZ_GRAPH_EXPORT static gzVoid   unregisterManager(gzDbManager *manager);

    GZ_GRAPH_EXPORT static gzVoid   unregisterManagers();
        
    GZ_GRAPH_EXPORT static gzNode   *loadDB(const gzString &url , gzString extension=GZ_EVALUATE_EXTENSION , gzSerializeAdapterFlags flags=GZ_DB_FLAGS_DEFAULT , gzULong version=0 , const gzString &password=GZ_EMPTY_STRING);

    GZ_GRAPH_EXPORT virtual gzNode  *loadDB(gzSerializeAdapter *adapter );

    GZ_GRAPH_EXPORT static gzBool   saveDB(gzNode *node , const gzString &url , gzString extension=GZ_EVALUATE_EXTENSION , gzSerializeAdapterFlags flags=GZ_DB_FLAGS_DEFAULT, gzULong version=0 , const gzString &password=GZ_EMPTY_STRING);

    GZ_GRAPH_EXPORT virtual gzBool  saveDB(gzNode *node , gzSerializeAdapter *adapter);

    GZ_GRAPH_EXPORT virtual gzString    getExtensions()=0;

    GZ_GRAPH_EXPORT virtual gzULong getVersion(const gzString &extension)=0;

    GZ_GRAPH_EXPORT static gzString getAllExtensions();

protected:

    GZ_GRAPH_EXPORT virtual gzVoid  registerManager(const gzString &extension);


    static gzRefDict<gzString,gzDbManager> s_registeredDbManagers;
};  

#endif // __GZ_NODE_H__

---