gzDynamic.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzDynamic.h
// Module       : gzBase
// Description  : Class definition of dynamic methods and vars
// Author       : Anders Modén
// Product      : GizmoBase 2.1.1
//
// Copyright © 2003- Saab Training Systems AB, Sweden
//
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...
//
// Who  Date    Description
//
// AMO  991002  Created file
//
// ******************************************************************************

#ifndef __GZ_DYNAMIC_H__
#define __GZ_DYNAMIC_H__

#include "gzBase.h"
#include "gzSerialize.h"
#include "gzExceptions.h"
#include "gzReference.h"
#include "gzNotify.h"
#include "gzGuid.h"

//------------------------- IID --------------------------------------------------
// Generic commands

const gzString      IIDS_DEBUG                  ="debug";
const gzULongLong   IID_DEBUG                   =LL(0x7fffffff00000001);

const gzString      IIDS_VERSION                ="version";
const gzULongLong   IID_VERSION                 =LL(0x7fffffff00000002);

const gzString      IIDS_LICENSE_EXPIRE_DAYS    ="licenseExpireDays";
const gzULongLong   IID_LICENSE_EXPIRE_DAYS     =LL(0x7fffffff00000003);

const gzString      IIDS_TEST                   ="test";
const gzULongLong   IID_TEST                    =LL(0x7fffffff00000004);

const gzULongLong   IID_NOT_SUPPORTED           =LL(0xFFFFFFFFFFFFFFFF);

//----------------------- Unique ID definitions for gizmo dynamic type -----------------------

const gzUShort GZ_DYNAMIC_TYPE_STRING_UNIQUE_ID     = 1;
const gzUShort GZ_DYNAMIC_TYPE_VOID_UNIQUE_ID       = 2;
const gzUShort GZ_DYNAMIC_TYPE_NUMBER_UNIQUE_ID     = 3;
const gzUShort GZ_DYNAMIC_TYPE_POINTER_UNIQUE_ID    = 4;
const gzUShort GZ_DYNAMIC_TYPE_REFERENCE_UNIQUE_ID  = 5;
const gzUShort GZ_DYNAMIC_TYPE_ERROR_UNIQUE_ID      = 6;
const gzUShort GZ_DYNAMIC_TYPE_LONGLONG_UNIQUE_ID   = 7;
const gzUShort GZ_DYNAMIC_TYPE_ARRAY_UNIQUE_ID      = 8;
const gzUShort GZ_DYNAMIC_TYPE_VEC2_UNIQUE_ID       = 9;
const gzUShort GZ_DYNAMIC_TYPE_VEC3_UNIQUE_ID       = 10;
const gzUShort GZ_DYNAMIC_TYPE_VEC4_UNIQUE_ID       = 11;
const gzUShort GZ_DYNAMIC_TYPE_CONTAINER_UNIQUE_ID  = 12;
const gzUShort GZ_DYNAMIC_TYPE_CHAIN_UNIQUE_ID      = 13;
const gzUShort GZ_DYNAMIC_TYPE_GUID_UNIQUE_ID       = 19;

//----------------------- general dynamic type -------------------------------------

const gzString  GZ_DYNAMIC_TYPE_STRING      =gzUniqueString("str"   ,GZ_DYNAMIC_TYPE_STRING_UNIQUE_ID); // System defined strings
const gzString  GZ_DYNAMIC_TYPE_VOID        =gzUniqueString("void"  ,GZ_DYNAMIC_TYPE_VOID_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_NUMBER      =gzUniqueString("num"   ,GZ_DYNAMIC_TYPE_NUMBER_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_POINTER     =gzUniqueString("ptr"   ,GZ_DYNAMIC_TYPE_POINTER_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_REFERENCE   =gzUniqueString("ref"   ,GZ_DYNAMIC_TYPE_REFERENCE_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_ERROR       =gzUniqueString("error" ,GZ_DYNAMIC_TYPE_ERROR_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_LONGLONG    =gzUniqueString("llnum" ,GZ_DYNAMIC_TYPE_LONGLONG_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_ARRAY       =gzUniqueString("array" ,GZ_DYNAMIC_TYPE_ARRAY_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_VEC2        =gzUniqueString("vec2"  ,GZ_DYNAMIC_TYPE_VEC2_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_VEC3        =gzUniqueString("vec3"  ,GZ_DYNAMIC_TYPE_VEC3_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_VEC4        =gzUniqueString("vec4"  ,GZ_DYNAMIC_TYPE_VEC4_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_CONTAINER   =gzUniqueString("cont"  ,GZ_DYNAMIC_TYPE_CONTAINER_UNIQUE_ID);
const gzString  GZ_DYNAMIC_TYPE_CHAIN       =gzUniqueString("chain" ,GZ_DYNAMIC_TYPE_CHAIN_UNIQUE_ID);  // Chain the command to a higher level of command
const gzString  GZ_DYNAMIC_TYPE_GUID        =gzUniqueString("guid"  ,GZ_DYNAMIC_TYPE_GUID_UNIQUE_ID);

const gzUByte GZ_UNIQUE_ID_ESCAPE_TOKEN=0xfc;

//******************************************************************************
// Class    : gzDynRefList
//                                  
// Purpose  : Internal utility class that manages reference counting in dynamic types
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  001030  Created 
//                                  
//******************************************************************************
class gzDynRefList : public gzList<gzReference>
{
public:
    
    gzDynRefList(){};

    gzDynRefList( const gzDynRefList &copy ):gzList<gzReference>(){ *this=copy; }

    virtual ~gzDynRefList(){ clear(); }

    virtual gzVoid onInsert(gzReference *item ) const {item->ref(); }

    virtual gzVoid onRemove(gzReference *item ) const {item->unref(); }

    virtual gzReference *cloneEntry(gzReference *item ) const { return item; }
};

//******************************************************************************
// Class    : gzDynamicType
//                                  
// Purpose  : Base class for gizmo dynamic data
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980912  Created 
//                                  
//******************************************************************************
class  gzDynamicType : public gzSerializeData , public gzTypeInterface
{
public:

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);

    GZ_BASE_EXPORT gzDynamicType(const gzDouble     &value);
    GZ_BASE_EXPORT gzDynamicType(const gzString     &value);
    GZ_BASE_EXPORT gzDynamicType(const gzVoid       *value);
    GZ_BASE_EXPORT gzDynamicType(const gzReference  *value);
    GZ_BASE_EXPORT gzDynamicType(const gzVec2       &value);
    GZ_BASE_EXPORT gzDynamicType(const gzVec3       &value);
    GZ_BASE_EXPORT gzDynamicType(const gzVec4       &value);
    GZ_BASE_EXPORT gzDynamicType(const char         *value);
    GZ_BASE_EXPORT gzDynamicType(const gzGUID       &value);

    GZ_BASE_EXPORT gzDynamicType();

    GZ_BASE_EXPORT gzDynamicType(const gzDynamicType & copy);

    GZ_BASE_EXPORT gzDynamicType & operator=(const gzDynamicType & copy);

    GZ_BASE_EXPORT virtual ~gzDynamicType();

    GZ_BASE_EXPORT gzBool               is(const gzString & dynamicType) const;
    GZ_BASE_EXPORT const gzString &     getDynamicType() const;
    GZ_BASE_EXPORT gzArray< gzUByte >   getDynamicData() const;
    GZ_BASE_EXPORT const gzDynRefList & getDynamicReferences() const;
    GZ_BASE_EXPORT gzBool               hasDynamicReferences() const;

    GZ_BASE_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter);
    GZ_BASE_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter);
    GZ_BASE_EXPORT virtual gzVoid pushBack(gzSerializeAdapter *adapter);
    GZ_BASE_EXPORT virtual gzULong  getDataSize(gzSerializeAdapter *adapter=NULL) const;


    GZ_BASE_EXPORT gzString         getString()     const;
    GZ_BASE_EXPORT gzDouble         getNumber()     const;
    GZ_BASE_EXPORT gzVoid *         getPointer()    const;
    GZ_BASE_EXPORT gzReference *    getReference()  const;

    GZ_BASE_EXPORT gzVec2           getVec2()       const;
    GZ_BASE_EXPORT gzVec3           getVec3()       const;
    GZ_BASE_EXPORT gzVec4           getVec4()       const;
    GZ_BASE_EXPORT gzGUID           getGUID()       const;

    GZ_BASE_EXPORT gzBool   operator ==(const gzDynamicType & compare) const;
    GZ_BASE_EXPORT gzBool   operator !=(const gzDynamicType & compare) const;

    GZ_BASE_EXPORT gzVoid           reset();

protected:
    
    gzString                            m_type;
    gzArray< gzUByte >                  m_data;
    gzLateBindData<gzDynRefList>        m_references;
};

//******************************************************************************
// Class    : gzDynamicTypeVoid
//                                  
// Purpose  : gzVoid
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class  gzDynamicTypeVoid : public gzDynamicType
{
public:
    GZ_BASE_EXPORT gzDynamicTypeVoid();
    GZ_BASE_EXPORT gzDynamicTypeVoid(const gzDynamicType &copy);
};

//******************************************************************************
// Class    : gzDynamicTypeChain
//                                  
// Purpose  : Chain a possible result evaluation to a higher level of command
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  031217  Created 
//                                  
//******************************************************************************
class  gzDynamicTypeChain : public gzDynamicType
{
public:
    GZ_BASE_EXPORT gzDynamicTypeChain();
    GZ_BASE_EXPORT gzDynamicTypeChain(const gzDynamicType &copy);
};


//------------------ gzDynamicTypeError standard values -----------------------

const gzString GZ_DYNAMIC_ERROR_VALUE_NOT_SET   =   gzUniqueString("Value not set"      ,14);
const gzString GZ_DYNAMIC_ERROR_NOT_IMPLEMENTED =   gzUniqueString("Not implemented"    ,15);
const gzString GZ_DYNAMIC_ERROR_NO_ERROR        =   gzUniqueString("OK"                 ,16);
const gzString GZ_DYNAMIC_ERROR_TEST_OK         =   gzUniqueString("Test OK"            ,17);
const gzString GZ_DYNAMIC_ERROR_TEST_FAIL       =   gzUniqueString("Test FAIL"          ,18);

//******************************************************************************
// Class    : gzDynamicTypeError
//                                  
// Purpose  :  Dynamic Errors
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class  gzDynamicTypeError : public gzDynamicType
{
public:
    GZ_BASE_EXPORT gzDynamicTypeError(const gzString &errorvalue);
    GZ_BASE_EXPORT gzDynamicTypeError(const gzDynamicType &copy);

    GZ_BASE_EXPORT gzString getError() const;
    GZ_BASE_EXPORT gzVoid   setError(const gzString &error);
    GZ_BASE_EXPORT operator gzString () const { return getError(); }
    GZ_BASE_EXPORT gzBool   isError() const;
};

//******************************************************************************
// Class    : gzDynamicTypeLongLong
//                                  
// Purpose  : Large Long Numbers
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class  gzDynamicTypeLongLong : public gzDynamicType
{
public:
    GZ_BASE_EXPORT gzDynamicTypeLongLong(const gzLongLong &value);
    GZ_BASE_EXPORT gzDynamicTypeLongLong(const gzDynamicType &copy);

    GZ_BASE_EXPORT gzLongLong getLongLong() const;
    GZ_BASE_EXPORT operator gzLongLong () const { return getLongLong(); }
};

//******************************************************************************
// Class    : gzDynamicTypeArray
//                                  
// Purpose  : Dynamic Array
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000623  Created 
//                                  
//******************************************************************************
class  gzDynamicTypeArray : public gzDynamicType
{
public:
    GZ_BASE_EXPORT gzDynamicTypeArray(const gzArray<gzDynamicType> &array);
    GZ_BASE_EXPORT gzDynamicTypeArray(const gzDynamicType &copy);
    GZ_BASE_EXPORT gzDynamicTypeArray();

    GZ_BASE_EXPORT gzArray<gzDynamicType> getArray() const;
    GZ_BASE_EXPORT operator gzArray<gzDynamicType> () const { return getArray(); }
};

//----------------------------------------------------------------------------------

const gzDynamicTypeError    GZ_DYN_ERR_OK(GZ_DYNAMIC_ERROR_NO_ERROR);
const gzDynamicTypeError    GZ_DYN_TEST_OK(GZ_DYNAMIC_ERROR_TEST_OK);
const gzDynamicTypeError    GZ_DYN_TEST_FAIL(GZ_DYNAMIC_ERROR_TEST_FAIL);
const gzDynamicTypeVoid     GZ_DYN_VOID;

GZ_BASE_EXPORT gzBool GZ_FAIL           (const gzDynamicType &result);  // TRUE if error but not  GZ_DYN_ERR_OK and not GZ_DYN_TEST_OK
GZ_BASE_EXPORT gzBool GZ_TEST_FAIL      (const gzDynamicType &result);  // TRUE if GZ_DYN_TEST_FAIL
GZ_BASE_EXPORT gzBool GZ_SUCCESS        (const gzDynamicType &result);  // TRUE if non error or GZ_DYN_ERR_OK or GZ_DYN_TEST_OK
GZ_BASE_EXPORT gzBool GZ_TEST_SUCCESS   (const gzDynamicType &result);  // TRUE if GZ_DYN_TEST_OK

#define GZ_DYN_ARG(n)           const gzDynamicType &a##n
#define GZ_DYN_ARG_TYPE(n)      const gzString &t##n
#define GZ_DYN_ARG_NULL(n)      const gzString &t##n=GZ_EMPTY_STRING

#define GZ_DYN_ARG_VOID(n)      GZ_DYN_ARG(n)=GZ_DYN_VOID
#define GZ_DYN_ARG_TYPE_VOID(n) GZ_DYN_ARG_TYPE(n)=GZ_DYNAMIC_TYPE_VOID



#define GZ_DYNAMIC_ATTRIBUTE_LIST   GZ_DYN_ARG_VOID(0),\
                                    GZ_DYN_ARG_VOID(1),\
                                    GZ_DYN_ARG_VOID(2),\
                                    GZ_DYN_ARG_VOID(3),\
                                    GZ_DYN_ARG_VOID(4),\
                                    GZ_DYN_ARG_VOID(5),\
                                    GZ_DYN_ARG_VOID(6),\
                                    GZ_DYN_ARG_VOID(7),\
                                    GZ_DYN_ARG_VOID(8),\
                                    GZ_DYN_ARG_VOID(9)

#define GZ_DYNAMIC_ATTRIBUTE_TYPE_LIST  GZ_DYN_ARG_TYPE_VOID(0),\
                                        GZ_DYN_ARG_TYPE_VOID(1),\
                                        GZ_DYN_ARG_TYPE_VOID(2),\
                                        GZ_DYN_ARG_TYPE_VOID(3),\
                                        GZ_DYN_ARG_TYPE_VOID(4),\
                                        GZ_DYN_ARG_TYPE_VOID(5),\
                                        GZ_DYN_ARG_TYPE_VOID(6),\
                                        GZ_DYN_ARG_TYPE_VOID(7),\
                                        GZ_DYN_ARG_TYPE_VOID(8),\
                                        GZ_DYN_ARG_TYPE_VOID(9)

#define GZ_DYNAMIC_ATTRIBUTE_LIST_IMP   GZ_DYN_ARG(0),\
                                        GZ_DYN_ARG(1),\
                                        GZ_DYN_ARG(2),\
                                        GZ_DYN_ARG(3),\
                                        GZ_DYN_ARG(4),\
                                        GZ_DYN_ARG(5),\
                                        GZ_DYN_ARG(6),\
                                        GZ_DYN_ARG(7),\
                                        GZ_DYN_ARG(8),\
                                        GZ_DYN_ARG(9)

#define GZ_DYNAMIC_ATTRIBUTE_TYPE_LIST_IMP  GZ_DYN_ARG_TYPE(0),\
                                            GZ_DYN_ARG_TYPE(1),\
                                            GZ_DYN_ARG_TYPE(2),\
                                            GZ_DYN_ARG_TYPE(3),\
                                            GZ_DYN_ARG_TYPE(4),\
                                            GZ_DYN_ARG_TYPE(5),\
                                            GZ_DYN_ARG_TYPE(6),\
                                            GZ_DYN_ARG_TYPE(7),\
                                            GZ_DYN_ARG_TYPE(8),\
                                            GZ_DYN_ARG_TYPE(9)

#define GZ_DYNAMIC_ATTRIBUTE_LIST_IMP_FORWARD       a0,a1,a2,a3,a4,a5,a6,a7,a8,a9
#define GZ_DYNAMIC_ATTRIBUTE_TYPE_LIST_IMP_FORWARD  t0,t1,t2,t3,t4,t5,t6,t7,t8,t9

#define GZ_DYA_9 gzDynamicTypeVoid()
#define GZ_DYA_8 GZ_DYA_9,gzDynamicTypeVoid()
#define GZ_DYA_7 GZ_DYA_8,gzDynamicTypeVoid()
#define GZ_DYA_6 GZ_DYA_7,gzDynamicTypeVoid()
#define GZ_DYA_5 GZ_DYA_6,gzDynamicTypeVoid()
#define GZ_DYA_4 GZ_DYA_5,gzDynamicTypeVoid()
#define GZ_DYA_3 GZ_DYA_4,gzDynamicTypeVoid()
#define GZ_DYA_2 GZ_DYA_3,gzDynamicTypeVoid()
#define GZ_DYA_1 GZ_DYA_2,gzDynamicTypeVoid()
#define GZ_DYA_0 GZ_DYA_1,gzDynamicTypeVoid()

#define GZ_DYT_9 GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_8 GZ_DYT_9,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_7 GZ_DYT_8,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_6 GZ_DYT_7,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_5 GZ_DYT_6,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_4 GZ_DYT_5,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_3 GZ_DYT_4,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_2 GZ_DYT_3,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_1 GZ_DYT_2,GZ_DYNAMIC_TYPE_VOID
#define GZ_DYT_0 GZ_DYT_1,GZ_DYNAMIC_TYPE_VOID

class gzDynamicInvokeInterface; // Forward decl .

typedef  gzDynamicType (GZ_CALLBACK  * gzDynamicMethod)(gzDynamicInvokeInterface *,GZ_DYNAMIC_ATTRIBUTE_LIST_IMP) ;

const gzString GZ_UNDEFINED_METHOD_NAME =   "UnDefMethod";

//******************************************************************************
// Class    : gzDynamicMethodID
//                                  
// Purpose  : Dynamic invokation method identity
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class gzDynamicMethodID 
{
public:
    gzDynamicMethodID():IID_method(0),IIDS_method(GZ_UNDEFINED_METHOD_NAME),method(0){};

    gzBool operator==(const gzDynamicMethodID &right) { return IID_method==right.IID_method; }
    gzBool operator!=(const gzDynamicMethodID &right) { return IID_method!=right.IID_method; }

    gzULongLong         IID_method;         
    gzString            IIDS_method;        
    gzDynamicMethod     method;             
    gzString            description;        
    gzString            argTypeCheck[10];   
};


//******************************************************************************
// Class    : gzDynamicEventData
//                                  
// Purpose  : Dynamic event response data
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class gzDynamicEventData : public gzReference
{
public:

    gzULongLong IID_event;
    gzDynamicType GZ_DYNAMIC_ATTRIBUTE_LIST_IMP_FORWARD;
};


class gzDynamicEventInterface; // Forward decl for slave interface

//******************************************************************************
// Class    : gzDynamicEventSubscriberInterface
//                                  
// Purpose  : Dynamic event response from dynamic interface
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class gzDynamicEventNotifyInterface : public gzNotifySlave<gzDynamicEventInterface,gzDynamicEventNotifyInterface,gzRefPointer<gzDynamicEventData> >
{
public:

    GZ_BASE_EXPORT virtual gzVoid onEvent( gzDynamicEventInterface * source , gzULongLong IID_event , GZ_DYNAMIC_ATTRIBUTE_LIST) = 0;

private:

    friend class gzNotifyMaster<gzDynamicEventInterface,gzDynamicEventNotifyInterface,gzRefPointer<gzDynamicEventData> >;
    GZ_BASE_EXPORT virtual gzVoid onNotify(gzDynamicEventInterface *master,gzRefPointer<gzDynamicEventData> &data,gzULong senderClass);

};

GZ_BASE_EXPORT gzArray<gzDynamicType> gzGetStringArguments(const gzString &params);

//******************************************************************************
// Class    : gzDynamicInvokeInterface
//                                  
// Purpose  : Dynamic invokation
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class  gzDynamicInvokeInterface
{
public:

    //---------------------- dynamic object methods ----------------------------
    GZ_BASE_EXPORT virtual  gzDynamicType               invokeMethod(const gzString &IIDS_method,GZ_DYNAMIC_ATTRIBUTE_LIST);
    GZ_BASE_EXPORT virtual  gzDynamicType               invokeMethod(gzULongLong IID_method,GZ_DYNAMIC_ATTRIBUTE_LIST);
    GZ_BASE_EXPORT virtual  gzDynamicType               invokeStringParamsMethod(const gzString &IIDS_method,const gzString &params);
    GZ_BASE_EXPORT virtual  gzDynamicType               invokeStringParamsMethod(gzULongLong IID_method,const gzString &params);
    GZ_BASE_EXPORT virtual  gzBool                      supportMethod(gzULongLong IID_method);
    GZ_BASE_EXPORT virtual  gzULongLong                 getMethodIID(const gzString &IIDS_method);
    GZ_BASE_EXPORT virtual  gzDynamicMethod             getDirectMethod(gzULongLong IID_method);
    GZ_BASE_EXPORT virtual  gzString                    getDescription(gzULongLong IID_method); 
    GZ_BASE_EXPORT virtual  gzArray<gzDynamicMethodID>  queryAllMethodIID();
};

//******************************************************************************
// Class    : gzDynamicEventInterface
//                                  
// Purpose  : Dynamic invokation
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000602  Created 
//                                  
//******************************************************************************
class  gzDynamicEventInterface : public gzNotifyMaster<gzDynamicEventInterface,gzDynamicEventNotifyInterface,gzRefPointer<gzDynamicEventData> >
{
public:

    //---------------------- dynamic events ------------------------------------

    GZ_BASE_EXPORT gzVoid   sendEvent(gzULongLong IID_event , GZ_DYNAMIC_ATTRIBUTE_LIST);
};


//******************************************************************************
// Class    : gzDynamicTypeCustom
//                                  
// Purpose  : Template for general purpose dynvars
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000624  Created 
//                                  
//******************************************************************************
template <class T> class  gzDynamicTypeCustom : public gzDynamicType
{
public:
    gzDynamicTypeCustom(const T &data);
    gzDynamicTypeCustom(const gzDynamicType &copy);
    gzDynamicTypeCustom();

    operator T () const;
    const gzDynamicTypeCustom<T> & operator =(const T &data);
};

template <class T> inline gzDynamicTypeCustom<T>::gzDynamicTypeCustom(const T &data)
{
    m_type=T::getDataTag();

    T & copy=(T &)data;

    m_data.setSize(copy.getDataSize());

    gzSerializeAdapterMemory mem(m_data.getAddress(),m_data.getSize());

    copy.write(&mem);
}

template <class T> inline gzDynamicTypeCustom<T>::gzDynamicTypeCustom(const gzDynamicType &copy)
{
    if(copy.getDynamicType()!=T::getDataTag())
        gzThrowFatal("Can not convert dynamic argument type '%s' to gzDynamicTypeCustom type '%s'!!",(const char *)copy.getDynamicType(),(const char *)T::getDataTag());

    m_data=copy.getDynamicData();
    m_type=copy.getDynamicType();

    if(copy.hasDynamicReferences())
    {
        if(copy.getDynamicReferences().entries())
        {
            m_references.get()=copy.getDynamicReferences();
        }
    }
}

template <class T> inline gzDynamicTypeCustom<T>::gzDynamicTypeCustom()
{
    m_type=T::getDataTag();

    T data;

    m_data.setSize(data.getDataSize());

    gzSerializeAdapterMemory mem(m_data.getAddress(),m_data.getSize());

    data.write(&mem);
}

template <class T> inline gzDynamicTypeCustom<T>::operator T () const
{
    T data;
    
    gzSerializeAdapterMemory mem(((gzArray<unsigned char> &)m_data).getAddress(),m_data.getSize());

    data.read(&mem);

    return data;
}

template <class T> inline const gzDynamicTypeCustom<T>  & gzDynamicTypeCustom<T>::operator =(const T &data)
{
    m_type=T::getDataTag();

    T & copy=(T &)data;

    m_data.setSize(copy.getDataSize());

    gzSerializeAdapterMemory mem(m_data.getAddress(),m_data.getSize());

    copy.write(&mem);

    return *this;
}

enum gzDynamicTypeEvent
{
    GZ_DYNAMIC_EVENT_REMOVE_ATTRIBUTE,
    GZ_DYNAMIC_EVENT_SET_ATTRIBUTE,
    GZ_DYNAMIC_EVENT_REMOVE_ALL_ATTRIBUTES,
    GZ_DYNAMIC_EVENT_ADD_USERDATA,              
    GZ_DYNAMIC_EVENT_REMOVE_USERDATA            
};

//******************************************************************************
// Class    : gzDynamicTypeContainer
//                                  
// Purpose  : A generic serializeable dictionary for gzDynamicTypes
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  011026  Created 
//                                  
//******************************************************************************

class gzDynamicTypeContainer : public gzSerializeData
{
public:

    // Creation

    GZ_BASE_EXPORT gzDynamicTypeContainer(gzULong hashsize=1);

    GZ_BASE_EXPORT virtual ~gzDynamicTypeContainer();

    GZ_BASE_EXPORT gzDynamicTypeContainer( const gzDynamicTypeContainer & copy);

    GZ_BASE_EXPORT gzDynamicTypeContainer & operator=(const gzDynamicTypeContainer & copy);

    // Attrib management

    GZ_BASE_EXPORT gzVoid setAttribute(const gzString &name , const gzDynamicType &attribute);

    GZ_BASE_EXPORT gzDynamicType getAttribute(const gzString &name) const;

    GZ_BASE_EXPORT gzBool hasAttribute(const gzString &name) const;

    GZ_BASE_EXPORT gzBool removeAttribute(const gzString &name);

    GZ_BASE_EXPORT gzVoid removeAllAttributes();

    GZ_BASE_EXPORT gzULong getNumberOfAttributes() const;

    GZ_BASE_EXPORT virtual gzVoid onAttributeEvent( gzDynamicTypeEvent reason , const gzString &name) {};

    // serializing

    GZ_BASE_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzVoid pushBack(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzULong  getDataSize(gzSerializeAdapter *adapter=NULL) const;

    // dynamic info

    GZ_BASE_EXPORT static const gzString getDataTag() { return GZ_DYNAMIC_TYPE_CONTAINER; }

private:

    friend class gzDynamicTypeContainerIterator;

    gzULong                                             m_hashSize;

    gzRefDict< gzString , gzRefData< gzDynamicType > > *m_dict;

};

//******************************************************************************
// Class    : gzDynamicTypeContainerIterator
//                                  
// Purpose  : Utility to iterator over a dynamic container
//                                  
// Notes    : 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  011201  Created 
//                                  
//******************************************************************************
class gzDynamicTypeContainerIterator 
{
public:

    GZ_BASE_EXPORT  gzDynamicTypeContainerIterator(const gzDynamicTypeContainer &container , const gzString &prefix="");

    GZ_BASE_EXPORT  virtual ~gzDynamicTypeContainerIterator();

    GZ_BASE_EXPORT  gzDynamicType *operator()(gzString *name=NULL);

    GZ_BASE_EXPORT  gzVoid reset();

    GZ_BASE_EXPORT  gzVoid remove();

    GZ_BASE_EXPORT  gzVoid setPrefix(const gzString &prefix);

private:

    gzDynamicTypeContainer & m_owner;

    gzDictIterator<gzString , gzRefData< gzDynamicType > >  *m_iterator;

    gzString m_prefix;
};

typedef gzDynamicTypeCustom<gzDynamicTypeContainer> gzDynamicTypeContainerData;


// Dynamic caster utilities

//******************************************************************************
// Class    : gzDynamic_Cast<CastToClass>
//                                  
// Purpose  : Utility to do a checked dynamic cast of dynamic typed data
//                                  
// Notes    : Throws exception if not possible  
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  021201  Created 
//                                  
//******************************************************************************
template<class T> inline T gzDynamic_Cast(const gzDynamicType &data)
{
    return (T)(gzDynamicTypeCustom<T>)data;
}

//******************************************************************************
// Class    : gzDynamic_Cast<CastToClass>
//                                  
// Purpose  : Utility to do a checked dynamic cast of dynamic typed data