Dump Ceda Namespace

>>> pyceda.namespace.DumpNameSpace(pyceda.cns,0)

results in the following dump of the entire ceda namespace:

class PyObject
{
    Size = 16 bytes
    CanCreate = 0
    model
    {
    }
    fields
    {
    }
    methods
    {
    }
    indirect interfaces
    {
    }
    direct interfaces
    {
    }
}
namespace Int64
    global function int64 Int64::Add(int64 x,int64 y)
    global function int64 Int64::Div(int64 x,int64 y)
    global function int64 Int64::Make(uint32 low,uint32 high)
    global function int64 Int64::Mult(int64 x,int64 y)
    global function int64 Int64::Neg(int64 x)
    global function int64 Int64::Sub(int64 x,int64 y)
namespace UInt64
    global function uint64 UInt64::Add(uint64 x,uint64 y)
    global function uint64 UInt64::Div(uint64 x,uint64 y)
    global function uint64 UInt64::Make(uint32 low,uint32 high)
    global function uint64 UInt64::Mult(uint64 x,uint64 y)
    global function uint64 UInt64::Sub(uint64 x,uint64 y)
namespace ceda
    global function void ceda::AddGcRoot(ptr object)
    global function bool ceda::AddPSpaceRoot(ceda::ConstStringZ name,ptr root)
    class ceda::AnyConstInterface
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::AnyInterface
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function ptr ceda::AsyncBindObjectInMemoryGivenOid(ceda::OID oid)
    global function void ceda::AsyncPermanentlyDeleteObject(ptr obj)
    global function void ceda::AsyncPermanentlyDeleteSubTree(ptr obj)
    struct ceda::BPlusTree
    {
        Size = 184 bytes
        CanCreate = 1
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
            ceda::IObject
        }
        direct interfaces
        {
            ceda::IPersistable
        }
    }
    class ceda::BcTypeOps
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function ptr ceda::BindObjectGivenOid(ceda::OID oid)
    global function ptr ceda::BindObjectInMemoryGivenOid(ceda::OID oid)
    global function ceda::ENavNamespaceResult ceda::BindPathDownwards(ptr& foundNode,ptr startNode,ceda::SubString path,ceda::xchar delimiter)
    global function void ceda::BindPythonSysOutputToTracer()
    adt ceda::CSpace
    {
        Size = 968 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            void Destroy()
            void EvictAllDgsNodes()
            ceda::ssize_t TryEvictDgsNodes(ceda::ssize_t maxNumDgsNodesToRetain)
            bool WaitForGarbageCollect()
            void Lock(ceda::ECSpaceLockMode mode)
            void Unlock()
            ceda::LockInfo BeginUnlock()
            void EndUnlock(ceda::LockInfo info)
            void AddGcRoot(ptr object)
            void RemoveGcRoot(ptr object)
            void StartGc()
            void StopGc()
            void RegisterGcObject(ptr object)
            void RegisterNonGcObject(ptr object)
            ceda::ssize_t GetNumObjects() const
            void SynchronousGc()
            ceda::ssize_t GetMaxNumDgsNodesToRetain() const
            void SetMaxNumDgsNodesToRetain(ceda::ssize_t n)
            int32 GetMilliSecsPerGc() const
            void SetMilliSecsPerGc(int32 t)
            ceda::ssize_t GetEvictionThreshold() const
            void SetEvictionThreshold(ceda::ssize_t totalSizeInBytes)
            int64 GetTotalNumCompletedGcs() const
            void** GetPtrSlotArray()
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::CSpaceStack_Pop(ceda::ssize_t count)
    global function void ceda::CSpaceStack_Push(ptr p)
    adt ceda::ChildNameSpaceIterator
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            bool AtEnd() const
            void Next()
            ceda::SubString GetName() const
            ceda::NameSpace* GetNameSpace() const
            void Close()
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ClassNameTranslation
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ClassNameTranslationTable
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::CloseCSpaceStack()
    global function void ceda::ClosePSpaceTxn(ceda::PersistStoreTxn* txn)
    typedef char16 const* ceda::ConstString16Z
    typedef char8 const* ceda::ConstString8Z
    typedef char8 const* ceda::ConstStringZ
    global function ceda::CSpace* ceda::CreateCSpace(int32 milliSecsPerGC,ceda::GCThreadFn fn)
    global function ceda::CSpace* ceda::CreateCSpace2(int32 milliSecsPerGC)
    class ceda::Date
    {
        Size = 4 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::DeclareReachable(ptr parent,ptr child,bool trace)
    enum ceda::EAsyncBindResult
    {
        Bound = 0
        Pending = 1
        DoesNotExist = 2
        NotHandled = 3
    }
    enum ceda::EByteCodeQualifier
    {
        Volatile = 1
        Const = 2
        Assignable = 4
        Movable = 8
        Offsettable = 16
    }
    enum ceda::ECSpaceLockMode
    {
        SharedRead = 0
        Exclusive = 1
        Transaction = 2
    }
    enum ceda::EFuncType
    {
        GlobalFunction = 0
        Functor = 1
        ClassMethod = 2
        InterfaceMethod = 3
    }
    enum ceda::ENSType
    {
        NST_Unknown = 0
        NST_Interface = 1
        NST_Class = 2
        NST_Variant = 3
        NST_Enum = 4
        NST_Functor = 5
        NST_Typedef = 6
        NST_GlobalFunction = 7
        NST_GlobalVariable = 8
    }
    enum ceda::ENameSpaceError
    {
        NSE_OK = 0
        NSE_COLON_EXPECTED = 1
        NSE_IDENTIFIER_EXPECTED = 2
        NSE_NAME_ALREADY_IN_USE = 3
        NSE_NAME_NOT_FOUND = 4
        NSE_NOT_A_NAMESPACE = 5
    }
    enum ceda::ENavNamespaceResult
    {
        NPR_OK = 0
        NPR_NOT_FOUND = 1
        NPR_AMBIGUOUS = 2
        NPR_SYNTAX_ERROR = 3
    }
    enum ceda::EOpenMode
    {
        OM_CREATE_NEW = 0
        OM_CREATE_ALWAYS = 1
        OM_OPEN_EXISTING = 2
        OM_OPEN_EXISTING_READ_ONLY = 3
        OM_OPEN_EXISTING_SHARED_READ = 4
        OM_OPEN_ALWAYS = 5
        OM_DELETE_EXISTING = 6
    }
    enum ceda::EReflectedClassBits
    {
        RCF_CLASS = 0
        RCF_MODEL = 1
        RCF_REFERENCES_MODEL = 2
        RCF_ADT = 3
        RCF_ALLOW_PASS_BY_VALUE = 4
        RCF_ALLOW_RETURN_BY_VALUE = 5
        RCF_REPLICATE_ON_DEMAND = 6
    }
    enum ceda::ERetMode
    {
        Void = 0
        Float32 = 1
        Float64 = 2
        Int8 = 3
        Int16 = 4
        Int32 = 5
        Int64 = 6
        Struct = 7
        PushRet = 8
    }
    enum ceda::ETypeByteCode
    {
        FT_VOID = 0
        FT_BOOL = 1
        FT_INT8 = 2
        FT_INT16 = 3
        FT_INT32 = 4
        FT_INT64 = 5
        FT_INT128 = 6
        FT_UINT8 = 7
        FT_UINT16 = 8
        FT_UINT32 = 9
        FT_UINT64 = 10
        FT_UINT128 = 11
        FT_FLOAT32 = 12
        FT_FLOAT64 = 13
        FT_CHAR8 = 14
        FT_CHAR16 = 15
        FT_STRING8 = 16
        FT_STRING16 = 17
        FT_CLASS = 32
        FT_INTERFACE = 33
        FT_TYPEDEF = 34
        FT_ENUM = 35
        FT_FUNCTOR = 36
        FT_VARIANT = 37
        FT_FUNCTION_PTR = 38
        FT_NOT_REFLECTED = 39
        FT_VOLATILE = 48
        FT_CONST = 49
        FT_ASSIGNABLE = 50
        FT_MOVABLE = 51
        FT_OFFSETTABLE = 52
        FT_POINTER = 53
        FT_REFERENCE = 54
        FT_INTERFACE_POINTER = 64
        FT_OPEN_VARIANT = 65
        FT_PREF = 66
        FT_CREF = 67
        FT_VECTOR = 68
        FT_DEQUE = 69
        FT_LIST = 70
        FT_SET = 71
        FT_BAG = 72
        FT_DYNARRAY = 73
        FT_ARRAY = 80
        FT_MAP = 81
        FT_PARAM_0 = 96
        FT_PARAM_1 = 97
        FT_PARAM_2 = 98
        FT_PARAM_3 = 99
        FT_PARAM_4 = 100
        FT_PARAM_5 = 101
        MDT_FLAGS = 160
        MDT_BOOL = 161
        MDT_INT32 = 162
        MDT_FLOAT64 = 163
        MDT_STRING = 164
        MDT_BEGIN_FUNCTOR = 165
        MDT_END_FUNCTOR = 166
        MDT_BEGIN_LIST = 167
        MDT_END_LIST = 168
        MDT_FUNCTOR_0 = 192
        MDT_FUNCTOR_1 = 193
        MDT_FUNCTOR_2 = 194
        MDT_FUNCTOR_3 = 195
        MDT_FUNCTOR_4 = 196
        MDT_FUNCTOR_5 = 197
        MDT_LIST_0 = 224
        MDT_LIST_1 = 225
        MDT_LIST_2 = 226
        MDT_LIST_3 = 227
        MDT_LIST_4 = 228
        MDT_LIST_5 = 229
    }
    typedef void* ceda::FieldAddress
    global function ceda::ENavNamespaceResult ceda::FindChildNsNodeWithLinearScan(ptr parent,ceda::SubString name,ptr& child)
    struct ceda::GCRoots
    {
        Size = 64 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
            ceda::IObject
        }
    }
    functor void ceda::GCThreadFn(ceda::CSpace* cs)
    global function ceda::CSpace* ceda::GetAssociatedCSpace(ptr obj)
    global function ceda::ILogStructuredStore* ceda::GetAssociatedLss(ptr po)
    global function ceda::PSpace* ceda::GetAssociatedPSpace(ptr po)
    global function ceda::PersistStore* ceda::GetAssociatedPersistStore(ptr po)
    global function ceda::ReflectionByteCode ceda::GetClassMethodArgByteCode(ceda::ReflectedClass const& c,ceda::ReflectedArg const& a)
    global function ceda::ReflectionByteCode ceda::GetClassMethodReturnTypeByteCode(ceda::ReflectedClass const& c,ceda::ReflectedClassMethod const& m)
    global function ceda::ssize_t ceda::GetEvictionThreshold()
    global function ceda::ReflectionByteCode ceda::GetFieldByteCode(ceda::ReflectedClass const& c,ceda::ReflectedField const& f)
    global function ceda::ReflectionByteCode ceda::GetFunctorArgByteCode(ceda::ReflectedFunctor const& f,ceda::ReflectedArg const& a)
    global function ceda::ReflectionByteCode ceda::GetFunctorReturnTypeByteCode(ceda::ReflectedFunctor const& f)
    global function ceda::ReflectionByteCode ceda::GetGlobalFunctionArgByteCode(ceda::ReflectedGlobalFunction const& f,ceda::ReflectedArg const& a)
    global function ceda::ReflectionByteCode ceda::GetGlobalFunctionReturnTypeByteCode(ceda::ReflectedGlobalFunction const& f)
    global function ceda::ReflectionByteCode ceda::GetGlobalVariableByteCode(ceda::ReflectedGlobalVariable const& g)
    global function ceda::ReflectionByteCode ceda::GetInterfaceAttributeByteCode(ceda::ReflectedInterface const& i,ceda::ReflectedAttribute const& a)
    global function ceda::ReflectionByteCode ceda::GetInterfaceMethodArgByteCode(ceda::ReflectedInterface const& i,ceda::ReflectedArg const& a)
    global function ceda::ReflectionByteCode ceda::GetInterfaceMethodReturnTypeByteCode(ceda::ReflectedInterface const& i,ceda::ReflectedInterfaceMethod const& m)
    global function ceda::ssize_t ceda::GetMaxNumDgsNodesToRetain()
    global function ceda::MetaData ceda::GetMetaData(ceda::ReflectionByteCode const& c)
    global function int32 ceda::GetMilliSecsPerGc()
    global function ceda::ReflectionByteCode ceda::GetModelFieldByteCode(ceda::ReflectedClass const& c,ceda::ReflectedModelField const& f)
    global function ceda::OID ceda::GetOid(ptr po)
    global function ceda::PSpace* ceda::GetPSpaceOfCSpace(ceda::CSpace* cs)
    global function ptr ceda::GetPSpaceRoot(ceda::ConstStringZ name)
    global function ceda::NameSpace* ceda::GetTheRootNameSpace()
    global function ceda::CSpace* ceda::GetThreadCSpace()
    global function ceda::PSpace* ceda::GetThreadPSpace()
    global function ceda::ReflectionByteCode ceda::GetTypeDefByteCode(ceda::ReflectedTypedef const& t)
    global function ceda::ReflectionByteCode ceda::GetVariantFieldByteCode(ceda::ReflectedVariant const& v,ceda::ReflectedField const& f)
    class ceda::Goid
    {
        Size = 20 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    ceda::OidSpaceGuid oidSpaceGuid
            [16]    ceda::OidLow oidLow
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::Guid
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    uint32 Data1
            [4]    uint16 Data2
            [6]    uint16 Data3
            [8]    uint8[8] Data4
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    struct ceda::HPTime
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    int64 m_ticks
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    interface ceda::IAssignableFieldNotifications
    {
        void OnAssign(bool localOp,ptr obj,ceda::Path const& path,ceda::FieldAddress fa)
    }
    interface ceda::IAsyncBindRequestHandler
    {
        ceda::MAsyncBind BeginAsyncBindRequest(ceda::OID oid)
        void EndAsyncBindRequest(ceda::OID oid)
    }
    interface ceda::IBiDirIterator
    {
        void Close()
        void const* GetElement()
        void Next()
        void Prev()
    }
    interface ceda::IKeyType
    {
        void SerialiseVariable(ceda::Archive& ar,void const* addr)
        ceda::InputArchive DeserialiseVariable(ceda::InputArchive ar,void* addr)
        ceda::InputArchive SkipVariable(ceda::InputArchive ar)
    }
    interface ceda::INsNode
    {
        ceda::ssize_t GetNumNsChildren()
        ceda::xstring GetChildNsNodeName(ceda::ssize_t i)
        ptr GetChildNsNode(ceda::ssize_t i)
        ceda::ENavNamespaceResult FindChildNsNode(ceda::SubString name,ptr& foundNode)
    }
    interface ceda::IObject
    {
        ceda::AnyInterface QueryInterface(ceda::ReflectedInterface const& ri)
        ceda::AnyInterface BindInterface(ceda::ReflectedInterface const& ri)
        ceda::ReflectedClass const* GetReflectedClass()
        void VisitObjects(ceda::IObjectVisitor& v)
        void OnGarbageCollect()
        void Destroy()
        ceda::ObjSysState& GetSysState()
    }
    class ceda::IObjectVisitor
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    interface ceda::IOffsetableFieldNotifications
    {
        void OnOffset(bool localOp,ptr obj,ceda::Path const& path,ceda::FieldAddress fa,int64 offset)
    }
    class ceda::IOperationCallBacks
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    interface ceda::IPersistable
    {
        void VisitPrefs(ceda::IPrefVisitor& v)
        bool RepresentsSubTree()
        void Serialise(ceda::Archive& ar)
        ceda::InputArchive Deserialise(ceda::InputArchive ar)
        void OnCreate(bool local)
        ceda::PersistObjState& GetPersistObjState()
    }
    class ceda::IPrefVisitor
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    interface ceda::IPythonSysOutCallBacks
    {
        void OnWriteToStdOut(ceda::SubString8 s)
        void OnWriteToStdErr(ceda::SubString8 s)
    }
    interface ceda::ISetFieldNotifications
    {
        void OnSetInsert(bool localOp,ptr obj,ceda::Path const& path,ceda::FieldAddress fa)
        void OnSetDelete(bool localOp,ptr obj,ceda::Path const& path,ceda::FieldAddress fa)
    }
    interface ceda::IVectorFieldNotifications
    {
        void OnVectorInsert(bool localOp,ptr obj,ceda::Path const& path,ceda::FieldAddress fa,ceda::ssize_t i1,ceda::ssize_t i2)
        void OnVectorErase(bool localOp,ptr obj,ceda::Path const& path,ceda::FieldAddress fa,ceda::ssize_t i1,ceda::ssize_t i2)
    }
    interface ceda::IXMap
    {
        void Construct()
        ceda::InputArchive Search(ceda::InputArchive ar,void const*& payload)
        void* Insert(void const* key)
        ceda::InputArchive DeserialiseAndInsert(ceda::InputArchive ar,void*& payload)
        ceda::ssize_t size()
        ceda::ssize_t GetPayloadOffset()
        ptr GetIterator()
        ptr GetKeyType()
    }
    interface ceda::IXSet
    {
        void Construct()
        ceda::InputArchive Insert(ceda::InputArchive ar)
        ceda::InputArchive Delete(ceda::InputArchive ar)
        ceda::InputArchive Find(ceda::InputArchive ar,bool& found)
        ceda::ssize_t size()
        void Serialise(ceda::Archive& ar)
        ceda::InputArchive Deserialise(ceda::InputArchive ar)
        ptr GetRootNode()
        ptr GetIterator()
        ceda::InputArchive ScanOver(ceda::InputArchive ar)
        ptr GetKeyType()
    }
    class ceda::Int64
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    uint32 low
            [4]    uint32 high
        }
        methods
        {
            int32 AsInt32() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::InternalNode
    {
        Size = 152 bytes
        CanCreate = 1
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
            ceda::IObject
        }
        direct interfaces
        {
            ceda::IPersistable
        }
    }
    class ceda::LeafNode
    {
        Size = 176 bytes
        CanCreate = 1
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
            ceda::IObject
        }
        direct interfaces
        {
            ceda::IPersistable
        }
    }
    class ceda::LockInfo
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::LssSettings
    {
        Size = 40 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    int32 flushTimeMilliSec
            [8]    float64 cleanerUtilisationPercent
            [16]    bool enableFileBuffering
            [17]    bool enableWriteThrough
            [20]    int32 maxNumSegmentsInCache
            [24]    int32 numSegmentsPerCheckPoint
            [28]    int32 segmentSize
            [32]    bool forceIncrementMSSN
            [33]    bool validateSUTDuringCheckPoint
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    model ceda::MAsyncBind
    {
        Size = 24 bytes
        CanCreate = 0
        model
        {
            [0]    ceda::EAsyncBindResult result    [0,-1)
            [8]    ptr po    [0,-1)
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    model ceda::MGuid
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
            [0]    ceda::Guid Value    [0,-1)
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::MarkPersistentAsDirtyWithoutTrace(ptr po)
    class ceda::MetaData
    {
        Size = 24 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            bool IsMoreMetaData() const
            bool IsMetaDataList() const
            bool IsEmptyMetaDataList() const
            bool IsNonemptyMetaDataList() const
            bool ExistsFunctor0(ceda::ConstStringZ name,bool& exists,ceda::xstring& errorReason) const
            bool GetBool(ceda::ConstStringZ name,bool& value,ceda::xstring& errorReason) const
            bool GetInt(ceda::ConstStringZ name,int32& value,ceda::xstring& errorReason) const
            bool GetDouble(ceda::ConstStringZ name,float64& value,ceda::xstring& errorReason) const
            bool GetString(ceda::ConstStringZ name,ceda::xstring& value,ceda::xstring& errorReason) const
            ceda::xstring GetString2(ceda::ConstStringZ name) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    adt ceda::NameSpace
    {
        Size = 120 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::NameSpaceElement FindElement(ceda::SubString name) const
            ceda::ENameSpaceError FindElementWithRelativePath(ceda::SubString relativePath,ceda::NameSpaceElement& nse) const
            ceda::NameSpaceElementIterator* GetElementIterator() const
            ceda::NameSpace* FindChildNameSpace(ceda::SubString name) const
            ceda::ChildNameSpaceIterator* GetChildNameSpaceIterator() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::NameSpaceElement
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ENSType GetType() const
            ceda::ReflectedInterface const* AsInterface() const
            ceda::ReflectedClass const* AsClass() const
            ceda::ReflectedVariant const* AsVariant() const
            ceda::ReflectedEnum const* AsEnum() const
            ceda::ReflectedFunctor const* AsFunctor() const
            ceda::ReflectedTypedef const* AsTypedef() const
            ceda::ReflectedGlobalFunction const* AsGlobalFunction() const
            ceda::ReflectedGlobalVariable const* AsGlobalVariable() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    adt ceda::NameSpaceElementIterator
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            bool AtEnd() const
            void Next()
            ceda::SubString GetName() const
            ceda::NameSpaceElement GetElement() const
            void Close()
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::OID
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ObjSysState
    {
        Size = 32 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function bool ceda::ObjectInThreadCSpace(ptr p)
    global function bool ceda::ObjectsBelongToDifferentCSpaces(ptr obj1,ptr obj2)
    global function bool ceda::ObjectsBelongToDifferentPSpaces(ptr po1,ptr po2)
    global function bool ceda::ObjectsBelongToDifferentPersistStores(ptr po1,ptr po2)
    typedef uint32 ceda::OidHigh
    typedef uint32 ceda::OidLow
    typedef ceda::Guid ceda::OidSpaceGuid
    struct ceda::OidSpaceMap
    {
        Size = 208 bytes
        CanCreate = 1
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
            ceda::IObject
        }
        direct interfaces
        {
            ceda::IPersistable
        }
    }
    global function void ceda::OnGarbageCollectPersistable(ptr po)
    global function void ceda::OpenCSpaceStack()
    global function ceda::PSpace* ceda::OpenPSpace(ceda::PersistStore* ps,ceda::ConstStringZ name,ceda::EOpenMode openMode,ceda::CSpace* cspace)
    global function ceda::PersistStoreTxn* ceda::OpenPSpaceTxn(ceda::ECSpaceLockMode mode)
    global function ceda::PersistStore* ceda::OpenPersistStore(ceda::ConstStringZ lssPath,ceda::EOpenMode openMode,ceda::PersistStoreSettings const& settings)
    adt ceda::PSpace
    {
        Size = 1352 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            void Close()
            bool CreatedNew() const
            ceda::CSpace* GetCSpace()
            ceda::PersistStore* GetPersistStore()
            ceda::ConstStringZ GetName() const
            void WriteDirtyObjectsToLss(bool flushToDisk)
            void MarkPersistableAsDirtyWithoutTrace(ptr po)
            ptr BindObject(ceda::OID oid)
            ptr BindObjectIfMemoryResident(ceda::OID oid)
            ptr TryBindObject(ceda::OID oid)
            void MakeMemoryResident(ceda::OID oid)
            ceda::MAsyncBind AsyncBind2(ceda::OID oid)
            ptr AsyncBind(ceda::OID oid)
            ptr GetAsyncBindRequestHandler() const
            void SetAsyncBindRequestHandler(ptr h)
            void DeclareObjectDoesNotExist(ceda::OID oid)
            void MakeObjectPersist(ceda::OidLow affiliateOidLow,ptr po)
            ceda::OID AllocateOid(ceda::OidHigh oidHigh,bool useIncrementalOidAllocations)
            ceda::OidHigh GetOidHighForOidAllocations() const
            void SetOidHighForOidAllocations(ceda::OidHigh oidHigh,bool useIncrementalOidAllocations)
            bool MakeObjectPersistWithGivenOID(ptr po,ceda::OID oid,bool trace)
            void DeclareReachable(ptr parent,ptr child,bool trace)
            void MakeReachableObjectsPersist(ptr po)
            ptr GetRoot(ceda::ConstStringZ name)
            bool AddRoot(ceda::ConstStringZ name,ptr root)
            bool RemoveRoot(ceda::ConstStringZ name)
            void AsyncPermanentlyDeleteSubTree(ptr obj)
            void AsyncPermanentlyDeleteObject(ptr obj)
            void SyncPermanentlyDeleteSubTree(ptr obj)
            void SyncPermanentlyDeleteObject(ptr obj)
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
            ceda::IObject
        }
    }
    class ceda::PSpaceLockMode
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::PersistObjState
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    adt ceda::PersistStore
    {
        Size = 1248 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            void Close()
            bool CreatedNew() const
            ceda::ILogStructuredStore* GetLss()
            void StartObjectDeletion()
            void WriteAllDirtyObjectsToLss(bool flushToDisk)
            ceda::PersistStoreTxn* OpenTxn(ceda::PSpaceLockMode* L,ceda::ssize_t n)
            int32 GetDosPeriod() const
            void SetDosPeriod(int32 time)
            ceda::ssize_t GetNumPSpaces() const
            ceda::ssize_t GetNumPersistableObjects() const
            ceda::TypeOpsId GetTypeOpsId(ceda::ReflectionByteCodeValue const& rbcv,ceda::TypeOps const& typeOps)
            ceda::BcTypeOps GetTypeOps(ceda::TypeOpsId tid)
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::PersistStoreSettings
    {
        Size = 64 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    ceda::ConstStringZ deltasDirPath
            [8]    ceda::LssSettings lssSettings
            [48]    ceda::ClassNameTranslationTable* translationTable
            [56]    bool startObjectDeletion
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    adt ceda::PersistStoreTxn
    {
        Size = 72 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            void Close()
            ceda::PersistStore* GetPersistStore()
            ceda::PSpace* OpenPSpace(ceda::ConstStringZ name,ceda::EOpenMode openMode,ceda::CSpace* cspace)
            void TransferPSpace(ceda::PSpace* dst,ceda::PSpace* src)
            bool DestroyPSpace(ceda::ConstStringZ name)
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::PythonCallback_WriteToStdErr(ceda::SubString8 s)
    global function void ceda::PythonCallback_WriteToStdOut(ceda::SubString8 s)
    class ceda::QualifiedByteCode
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    typedef ceda::ssize_t ceda::RSN
    class ceda::ReadMetaData
    {
        Size = 24 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            bool IsMoreMetaData() const
            bool IsMetaDataList() const
            bool IsEmptyMetaDataList() const
            bool IsNonemptyMetaDataList() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedArg
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedAttribute
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedClass
    {
        Size = 288 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            uint32 GetFlags() const
            bool IsStruct() const
            bool IsModel() const
            bool ReferencesModel() const
            bool IsAdt() const
            bool ReplicateOnDemand() const
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetSize() const
            ceda::ssize_t GetNumFields() const
            ceda::ReflectedField const& GetField(ceda::ssize_t i) const
            ceda::ssize_t GetNumModelFields() const
            ceda::ReflectedModelField const& GetModelField(ceda::ssize_t i) const
            ceda::ssize_t GetNumMethods() const
            ceda::ReflectedClassMethod const& GetMethod(ceda::ssize_t i) const
            ceda::ssize_t GetNumIndirectInterfaces() const
            ceda::ssize_t GetNumDirectInterfaces() const
            ceda::ssize_t GetNumInterfaces() const
            ceda::ConstStringZ GetInterfaceName(ceda::ssize_t i) const
            bool CanCreate() const
            ptr Create() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedClassMethod
    {
        Size = 56 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            bool IsConst() const
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetNumArgs() const
            ceda::ReflectedArg const& GetArg(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedDepField
    {
        Size = 32 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetOffset() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedEnum
    {
        Size = 56 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            bool ValuesRedefined() const
            int32 GetCount() const
            int32 GetValue(int32 i) const
            bool GetEnable(int32 i) const
            ceda::ConstStringZ GetString(int32 i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedField
    {
        Size = 24 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetOffset() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedFunction
    {
        Size = 40 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetNumArgs() const
            ceda::ReflectedArg const& GetArg(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedFunctor
    {
        Size = 48 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetNumArgs() const
            ceda::ReflectedArg const& GetArg(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedGlobalFunction
    {
        Size = 56 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetNumArgs() const
            ceda::ReflectedArg const& GetArg(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedGlobalVariable
    {
        Size = 32 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            void* GetAddress() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedInterface
    {
        Size = 80 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetNumBaseInterfaces() const
            ceda::ConstStringZ GetBaseInterfaceName(ceda::ssize_t i) const
            ceda::ssize_t GetNumBaseMethods() const
            ceda::ssize_t GetNumMethods() const
            ceda::ReflectedInterfaceMethod const& GetMethod(ceda::ssize_t i) const
            ceda::ssize_t GetNumAttributes() const
            ceda::ReflectedAttribute const& GetAttribute(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedInterfaceMethod
    {
        Size = 48 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            bool IsConst() const
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetNumArgs() const
            ceda::ReflectedArg const& GetArg(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedModelField
    {
        Size = 48 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetOffset() const
            bool Present() const
            ceda::RSN GetRsn1() const
            ceda::RSN GetRsn2() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedReturnType
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedTypedef
    {
        Size = 24 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectedVariant
    {
        Size = 192 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ConstStringZ GetName() const
            ceda::ssize_t GetSize() const
            ceda::ssize_t GetNumFields() const
            ceda::ReflectedField const& GetField(ceda::ssize_t i) const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::ReflectionByteCode
    {
        Size = 24 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            ceda::ReflectionByteCode Clone()
            bool IsNull() const
            uint8 ReadType()
            uint8 ReadByte()
            bool ReadBool()
            int16 ReadInt16()
            int32 ReadInt32()
            float64 ReadFloat64()
            ceda::ConstStringZ ReadString()
            ceda::ReflectionByteCode& increment()
            void ScanPastBool()
            void ScanPastInt16()
            void ScanPastInt32()
            void ScanPastString()
            void ScanPastFloat64()
            ceda::ReflectedInterface const* GetReflectedInterface() const
            ceda::ReflectedClass const* GetReflectedClass() const
            ceda::ReflectedVariant const* GetReflectedVariant() const
            ceda::ReflectedTypedef const* GetReflectedTypedef() const
            ceda::ReflectedEnum const* GetReflectedEnum() const
            ceda::ReflectedFunctor const* GetReflectedFunctor() const
            void ScanMetaDataItem()
            void ScanType()
            void AdvanceToUnderlyingType()
            uint32 AdvanceToUnderlyingType2()
            uint8 GetUnderlyingType() const
            bool IsPOD() const
            bool IsConst() const
            ceda::ssize_t GetTypeSize() const
            ceda::ssize_t GetTypeSizeOnUnderlyingType() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    struct ceda::ReflectionByteCodeValue
    {
        Size = 72 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::RegisterGcObject(ptr object)
    global function void ceda::RegisterNonGcObject(ptr object)
    global function void ceda::RemoveGcRoot(ptr object)
    global function bool ceda::RemovePSpaceRoot(ceda::ConstStringZ name)
    typedef uint32 ceda::SeidHigh
    typedef uint32 ceda::SeidLow
    global function void ceda::SetEvictableObjectSizeInBytes(ptr obj,ceda::ssize_t size)
    global function void ceda::SetEvictionThreshold(ceda::ssize_t totalSizeInBytes)
    global function void ceda::SetMaxNumDgsNodesToRetain(ceda::ssize_t n)
    global function void ceda::SetMilliSecsPerGc(int32 t)
    global function void ceda::SetThreadCSpace(ceda::CSpace* p)
    global function void ceda::SetThreadPSpace(ceda::PSpace* p)
    global function void ceda::SetTouched(ptr obj)
    global function void ceda::SetTraceFile2(char8 const* path,bool appendToExistingFile,bool traceTime)
    global function void ceda::StartGc()
    global function void ceda::StopGc()
    typedef ceda::SubString8 ceda::SubString
    class ceda::SubString16
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    char16 const* m_p1
            [8]    char16 const* m_p2
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::SubString8
    {
        Size = 16 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    char8 const* m_p1
            [8]    char8 const* m_p2
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    global function void ceda::SyncPermanentlyDeleteObject(ptr obj)
    global function void ceda::SyncPermanentlyDeleteSubTree(ptr obj)
    global function ptr ceda::SynchronousDeepCopyPersistableObject(ptr po)
    global function void ceda::SynchronousGc()
    typedef ceda::ssize_t ceda::TIN
    functor void ceda::ThreadTaskFunctor()
    global function void ceda::TransferCSpace(ceda::CSpace* src,ceda::CSpace* dst)
    global function ptr ceda::TryBindObjectGivenOid(ceda::OID oid)
    typedef ceda::ssize_t ceda::TypeOpsId
    class ceda::UInt64
    {
        Size = 8 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
            [0]    uint32 low
            [4]    uint32 high
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    adt ceda::XTarget
    {
        Size = 280 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
            void Unregister()
            ceda::dsTarget const& GetdsTarget()
            ceda::TIN GetTin()
            void RegisterReflectedInterface(ceda::ReflectedInterface const* e)
            xvector const& GetInterfaceRegistry() const
            void RegisterReflectedClass(ceda::ReflectedClass const* e)
            xvector const& GetClassRegistry() const
            void RegisterReflectedVariant(ceda::ReflectedVariant const* e)
            xvector const& GetVariantRegistry() const
            void RegisterReflectedEnum(ceda::ReflectedEnum const* e)
            xvector const& GetEnumRegistry() const
            void RegisterReflectedFunctor(ceda::ReflectedFunctor const* e)
            xvector const& GetFunctorRegistry() const
            void RegisterReflectedTypedef(ceda::ReflectedTypedef const* e)
            xvector const& GetTypedefRegistry() const
            void RegisterReflectedGlobalFunction(ceda::ReflectedGlobalFunction const* e)
            xvector const& GetGlobalFunctionRegistry() const
            void RegisterReflectedGlobalVariable(ceda::ReflectedGlobalVariable const* e)
            xvector const& GetGlobalVariableRegistry() const
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    class ceda::dsTarget
    {
        Size = 40 bytes
        CanCreate = 0
        model
        {
        }
        fields
        {
        }
        methods
        {
        }
        indirect interfaces
        {
        }
        direct interfaces
        {
        }
    }
    typedef int64 ceda::ssize_t
    typedef char8 ceda::xchar
    typedef string8 ceda::xstring