mdobject.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2004, Matt Beard
 *  Portions copyright (c) 2002, BBC R&D
 *
 *  This software is provided 'as-is', without any express or implied warranty.
 *  In no event will the authors be held liable for any damages arising from
 *  the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must
 *       not claim that you wrote the original software. If you use this
 *       software in a product, an acknowledgment in the product
 *       documentation would be appreciated but is not required.
 *  
 *    2. Altered source versions must be plainly marked as such, and must
 *       not be misrepresented as being the original software.
 *  
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */
#ifndef MXFLIB__MDOBJECT_H
#define MXFLIB__MDOBJECT_H


// STL Includes
#include <string>
#include <list>
#include <map>


// mxflib includes
#include <mxflib/primer.h>


namespace mxflib
{
    class SymbolSpace : public std::map<std::string, ULPtr>, public RefCount<SymbolSpace>
    {
    protected:
        static SymbolSpaceMap AllSymbolSpaces;                  

        std::string SymName;                                    

    private:
        SymbolSpace(const SymbolSpace &rhs);

    public:
        SymbolSpace(std::string Name) : SymName(Name)
        {
            SymbolSpaceMap::iterator it = AllSymbolSpaces.find(Name);

            if(it != AllSymbolSpaces.end())
            {
                error("Duplicate symbol space name \"%s\"\n");
            }

            AllSymbolSpaces.insert(SymbolSpaceMap::value_type(Name, this));
        };



        bool AddSymbol(std::string Symbol, ULPtr &UL)
        {
            iterator it = find(Symbol);
            if(it != end()) return false;

            insert(value_type(Symbol, UL));

            return true;
        }


        ULPtr Find(std::string Symbol, bool SearchAll = false)
        {
            iterator it = find(Symbol);

            if(it != end()) return (*it).second;

            if(SearchAll)
            {
                SymbolSpaceMap::iterator map_it = AllSymbolSpaces.begin();
                while(map_it != AllSymbolSpaces.end())
                {
                    it = (*map_it).second->find(Symbol);
                    if(it != end()) return (*it).second;

                    map_it++;
                }
            }

            return NULL;
        }

        static SymbolSpacePtr FindSymbolSpace(std::string Name)
        {
            SymbolSpaceMap::iterator it = AllSymbolSpaces.find(Name);

            if(it != AllSymbolSpaces.end()) return (*it).second;

            return NULL;
        }

        const std::string &Name(void) const { return SymName; }
    };
}


namespace mxflib
{
    // Forward declare so the class can include pointers to itself
    class MDOType;

    typedef SmartPtr<MDOType> MDOTypePtr;

    typedef ParentPtr<MDOType> MDOTypeParent;

    typedef std::list<MDOTypePtr> MDOTypeList;

    typedef std::map<std::string, MDOTypePtr> MDOTypeMap;

    // Forward declare the ObjectInterface
    class ObjectInterface;
}



namespace mxflib
{
#define MXFLIB_MAXDICTDEPTH 32

    typedef ClassUsage DictUse;

    const ClassUsage DICT_USE_NONE = ClassUsageNULL;
    
    const ClassUsage DICT_USE_REQUIRED = ClassUsageRequired;
    
    const ClassUsage DICT_USE_ENCODER_REQUIRED = ClassUsageEncoderRequired;
    
    const ClassUsage DICT_USE_DECODER_REQUIRED = ClassUsageDecoderRequired;
    
    const ClassUsage DICT_USE_OPTIONAL = ClassUsageOptional;
    
    const ClassUsage DICT_USE_DARK = ClassUsageDark;
    
    const ClassUsage DICT_USE_TOXIC = ClassUsageToxic;

    const ClassUsage DICT_USE_BEST_EFFORT = ClassUsageBestEffort;

    /*
    ** Enumeration type for key formats
    */
    typedef enum
    {
        DICT_KEY_NONE = 0,
        DICT_KEY_1_BYTE = 1,
        DICT_KEY_2_BYTE = 2,
        DICT_KEY_4_BYTE = 4,
        DICT_KEY_AUTO = 3
    } DictKeyFormat;


    /*
    ** Enumeration type for length formats
    */
    typedef enum
    {
        DICT_LEN_NONE = 0,
        DICT_LEN_1_BYTE = 1,
        DICT_LEN_2_BYTE = 2,
        DICT_LEN_4_BYTE = 4,
        DICT_LEN_BER = 3
    } DictLenFormat;


    typedef ClassRef DictRefType;

    const ClassRef DICT_REF_NONE = ClassRefNone;

    const ClassRef DICT_REF_STRONG = ClassRefStrong;

    const ClassRef DICT_REF_WEAK = ClassRefWeak;

    const ClassRef DICT_REF_TARGET = ClassRefTarget;


/* Notes about the structure of dictionaries...
   ============================================

   The dictionary is held as a list of MDOType objects, each of 
   which holds information about a 'type' held in the dictionary.

   The dictionary is generally tree structured, with some types
   being children of others (this matches the sets with child items
   of an MXF file) When an item is a child it contains a pointer to
   its parent.  Each parent item contain pointers to each child item
   through derivation from MDOTypeMap (maps child name to pointer to
   child item). Care should be taken iterating this map as the
   order is likely to be alphabetical rather than dictionary order
   so where dictionary order is important (such as packs) iterate
   through the ChildList property.

   Inheritance is supported where a type is regarded as a modified
   version of another (base) type. The mechanism for inheritance is
   that a derived MDOType will be a copy of the base MDOType
   with a link back to the base in 'Base'. The 'Children' lists is
   copied and new child types are added to these lists.
   If a child of a derived type has the same name as a child of
   the base it is regarded as a replacement. 
*/
}


namespace mxflib
{
    class MDOType : public RefCount<MDOType>, public MDOTypeMap
    {
    protected:
        MDContainerType ContainerType;

        std::string RootName;           

    protected:
        MDTypePtr ValueType;            

    public:
        MDOTypeParent Base;             

    protected:
        StringList ChildOrder;          
        MDOTypeList ChildList;          
        MDOTypeParent Parent;           
        ULPtr TypeUL;                   

        /* Dictionary data */
        DataChunk       Key;            
        DataChunk       GlobalKey;      
        std::string     DictName;       
        std::string     Detail;         
        std::string     TypeName;       
        DictKeyFormat   KeyFormat;      
        DictLenFormat   LenFormat;      
        unsigned int    minLength;      
        unsigned int    maxLength;      
        DictUse         Use;            
        DataChunk       Default;        
        DataChunk       DValue;         
        ClassRef        RefType;        
        MDOTypeParent   RefTarget;      
        std::string     RefTargetName;  


        MDOType();

    public:
        MDOType(MDContainerType ContainerType, std::string RootName, std::string Name, std::string Detail, MDTypePtr Type, 
                DictKeyFormat KeyFormat, DictLenFormat LenFormat, unsigned int minLen, unsigned int maxLen, DictUse Use)
            : ContainerType(ContainerType), RootName(RootName), ValueType(Type), DictName(Name), Detail(Detail),
              KeyFormat(KeyFormat), LenFormat(LenFormat), minLength(minLen), maxLength(maxLen), Use(Use)
        {
            // MaxLength = 0 is used for maxlength = unbounded
            if(maxLength == 0) maxLength = (unsigned int)-1;

            if(Type) TypeName = Type->Name();
            else TypeName = Name;

            // Set the name lookup - UL lookup set when key set
            NameLookup[RootName + Name] = this;

            // Start of with no referencing details
            RefType = ClassRefNone;
        };

        void SetRef(ClassRef Type, ULPtr &Target, std::string TargetName = "")
        {
            ASSERT(Target);

            RefType = Type;
            RefTarget = Find(Target);

            if(!RefTarget)
            {
                error("Unknown type UL:%s in MDOType::SetRef()\n", Target->GetString().c_str());
                return;
            }
            
            if(TargetName != "") RefTargetName = TargetName;
            else RefTargetName = RefTarget->Name();
        }

        void SetRef(ClassRef Type, MDOTypePtr Target, std::string TargetName = "")
        {
            RefType = Type;
            RefTarget = Target;
            
            if(TargetName != "") RefTargetName = TargetName;
            else RefTargetName = Target->Name();
        }

        void Derive(MDOTypePtr &BaseEntry);


        void ReDerive(MDOTypePtr &BaseEntry);

        const MDContainerType &GetContainerType(void) const { return (const MDContainerType &)ContainerType; };

        ClassRef GetRefType(void) const { return RefType; };

        MDOTypePtr GetRefTarget(void) const { return RefTarget; };


        std::string GetRefTargetName(void) const { return RefTargetName; };

        std::string Name(void) const
        {
            return DictName;
        }

        std::string FullName(void) const
        {
            return RootName + DictName;
        }

        const DataChunk &GetDefault(void) const { return Default; }

        const DataChunk &GetDValue(void) const { return DValue; }

        const ULPtr &GetTypeUL(void) const { return TypeUL; }

        unsigned int GetMinLength(void) const { return minLength; }

        unsigned int GetMaxLength(void) const { return maxLength; }

        const MDTypePtr &GetValueType(void) const { return ValueType; }


        const StringList &GetChildOrder(void) const { return ChildOrder; }

        const MDOTypeList &GetChildList(void) const { return ChildList; }

        MDOTypePtr Child(std::string Name)
        {
            MDOTypeMap::iterator it = find(Name);
            if(it != end()) return (*it).second;
            return NULL;
        }

        MDOTypePtr Child(ULPtr &ChildType)
        {
            MDOTypeMap::iterator it = begin();
            while(it != end()) 
            { 
                if(((*it).second->TypeUL) && (*((*it).second->TypeUL) == *ChildType)) return (*it).second; 
                it++;
            }
            return NULL;
        }

        const DictKeyFormat &GetKeyFormat(void) const { return KeyFormat; }

        const DictLenFormat &GetLenFormat(void) const { return LenFormat; }

        std::pair<iterator, bool> insert(MDOTypePtr NewType) 
        { 
            std::string NewName = NewType->Name();
            std::pair<iterator, bool> Ret = MDOTypeMap::insert(MDOTypeMap::value_type(NewName, NewType));
            ChildList.push_back(NewType);
            ChildOrder.push_back(NewName);
            return Ret;
        }

        ULPtr &GetUL(void) { return TypeUL; }

        const DataChunk &GetKey(void) { return Key; }

        const DataChunk &GetGlobalKey(void) { return GlobalKey; }

        ClassUsage GetUse(void) { return (ClassUsage)Use; }

        bool IsA(std::string BaseType);

        bool IsA(MDOTypePtr &BaseType);
        
        bool IsA(const UL &BaseType);

        bool IsA(ULPtr &BaseType) { return IsA(*BaseType); }

        void ReDefine(std::string NewDetail, std::string NewBase, unsigned int NewMinSize, unsigned int NewMaxSize);
        
        void ReDefine(std::string NewDetail)
        {
            if(NewDetail.length()) Detail = NewDetail;
        }

    //** Static Dictionary Handling data and functions **
    //***************************************************
    protected:
        static MDOTypeList  AllTypes;   
        static MDOTypeList  TopTypes;   

        static std::map<UL, MDOTypePtr> ULLookup;
        
        static std::map<UL, MDOTypePtr> ULLookupVer1;

        static MDOTypeMap NameLookup;

    public:

        enum DictionaryItems
        {
            DICT_ITEM_USE = 1,
            DICT_ITEM_REFTYPE = 2,
            DICT_ITEM_CONTAINERTYPE = 4,
            DICT_ITEM_MINLENGTH = 8,
            DICT_ITEM_MAXLENGTH = 16,
            DICT_ITEM_KEYFORMAT = 32,
            DICT_ITEM_LENFORMAT = 64,
            DICT_ITEM_DVALUE = 128
        };

    protected:
        static PrimerPtr StaticPrimer;

    public:
        static void LoadDict(const char *DictFile, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols)
        {
            LoadDictionary(DictFile, DefaultSymbolSpace);
        }

        static void LocateRefTypes(void);

        static PrimerPtr MakePrimer(bool SetStatic = false);
        
        static PrimerPtr GetStaticPrimer(void) 
        { 
            if( !StaticPrimer) MakePrimer(true); 
            return StaticPrimer;
        }

        static MDOTypePtr Find(std::string BaseType, bool SearchAll = false) { return Find(BaseType, MXFLibSymbols, SearchAll); }
        
        static MDOTypePtr Find(std::string BaseType, SymbolSpacePtr &SymSpace, bool SearchAll = false);

        static MDOTypePtr Find(const UL& BaseUL);
        static MDOTypePtr Find(Tag BaseTag, PrimerPtr BasePrimer);

        static MDOTypePtr DefineClass(ClassRecordPtr &ThisClass, SymbolSpacePtr DefaultSymbolSpace, MDOTypePtr Parent = NULL);

        static MDOTypePtr DefineClass(ClassRecordPtr &ThisClass, MDOTypePtr Parent = NULL, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols)
        {
            return DefineClass(ThisClass, DefaultSymbolSpace, Parent);
        }

    protected:
        static void XML_startElement(void *user_data, const char *name, const char **attrs);
        static void XML_endElement(void *user_data, const char *name);
        static void XML_warning(void *user_data, const char *msg, ...);
        static void XML_error(void *user_data, const char *msg, ...);
        static void XML_fatalError(void *user_data, const char *msg, ...);
    };
}


namespace mxflib
{
    // Forward declare so the class can include pointers to itself
    class MDObject;
    class MDObjectPtr;
    class MDObjectParent;

    class MDObjectPtr : public SmartPtr<MDObject>
    {
    public:
        MDObjectPtr() : SmartPtr<MDObject>() {};
//      MDObjectPtr(MDObject * ptr) : SmartPtr<MDObject>(ptr) {};
        MDObjectPtr(IRefCount<MDObject> * ptr) : SmartPtr<MDObject>(ptr) {};

        MDObjectPtr operator[](const char *ChildName);
        MDObjectPtr operator[](MDOTypePtr &ChildType);
        MDObjectPtr operator[](const UL &ChildType);
        MDObjectPtr operator[](ULPtr &ChildType);
    };

    class MDObjectParent : public ParentPtr<MDObject>
    {
    public:
        MDObjectParent() : ParentPtr<MDObject>() {};
        MDObjectParent(IRefCount<MDObject> * ptr) : ParentPtr<MDObject>(ptr) {};


        void operator=(const MDObjectPtr &sp) { SmartPtr<MDObject>::operator=(sp); }


        void operator=(RefCount<MDObject> *Ptr) { SmartPtr<MDObject>::operator=(Ptr); }

        MDObjectPtr operator[](const char *ChildName);
        MDObjectPtr operator[](MDOTypePtr &ChildType);
        MDObjectPtr operator[](const UL &ChildType);
        MDObjectPtr operator[](ULPtr &ChildType);
    };

    class MDObjectList : public RefCount<MDObjectList>, public std::list<MDObjectPtr> {};
    typedef SmartPtr<MDObjectList> MDObjectListPtr;

    typedef std::pair<std::string,MDObjectPtr> MDObjectNamedListItem;
    typedef std::list<MDObjectNamedListItem> MDObjectNamedList;

    typedef std::pair<UL,MDObjectPtr> MDObjectULListItem;
    typedef std::list<MDObjectULListItem> MDObjectULList;
}


namespace mxflib
{
    class MDObject : public RefCount<MDObject>, public MDObjectULList
    {
    protected:
        MDOTypePtr Type;

        MDObjectPtr Link;

        bool IsConstructed;             
        UInt64 ParentOffset;            
        UInt32 KLSize;                  
        MDObjectParent Parent;          
        MXFFileParent ParentFile;       
        ULPtr TheUL;                    
        Tag TheTag;                     

        std::string ObjectName;         

        bool Modified;                  

        ObjectInterface *Outer;         

    public:
        typedef std::string (*ULTranslator)(ULPtr,const Tag *);

    protected:
        static ULTranslator UL2NameFunc;

        static bool ParseDark;

    public:
        MDValuePtr Value;

    protected:

        void ULCtor(void);

    public:

        MDObject(std::string BaseType, SymbolSpacePtr &SymSpace = MXFLibSymbols );

        MDObject(MDOTypePtr BaseType);

        MDObject(const UL &BaseUL) { TheUL = new UL(BaseUL); ULCtor(); }

        MDObject(const ULPtr &BaseUL) { TheUL = BaseUL; ULCtor(); }

        MDObject(Tag BaseTag, PrimerPtr BasePrimer);

        void Init(void);

        ~MDObject();


        MDObjectPtr AddChild(std::string ChildName, bool Replace) { return AddChild(ChildName, MXFLibSymbols, Replace); }


        MDObjectPtr AddChild(std::string ChildName, SymbolSpacePtr &SymSpace = MXFLibSymbols, bool Replace = true);

    
        MDObjectPtr AddChild(MDOTypePtr ChildType, bool Replace = true);
        

        MDObjectPtr AddChild(void);

        MDObjectPtr AddChild(const UL &ChildType, bool Replace = true);
        
        MDObjectPtr AddChild(ULPtr &ChildType, bool Replace = true) { return AddChild(*ChildType, Replace); }

        MDObjectPtr AddChild(MDObjectPtr &ChildObject, bool Replace = false);

    protected:

        MDObjectPtr AddChildInternal(MDObjectPtr ChildObject, bool Replace = false);

    public:

        void RemoveChild(std::string ChildName);

        void RemoveChild(MDOTypePtr &ChildType);

        void RemoveChild(ULPtr &ChildType);

        void RemoveChild(MDObjectPtr ChildObject);

        MDObjectPtr operator[](std::string ChildName);
        MDObjectPtr Child(std::string ChildName) { return operator[](ChildName); };
        MDObjectListPtr ChildList(std::string ChildName);
        MDObjectListPtr ChildList(const UL &ChildType);
        MDObjectListPtr ChildList(const ULPtr &ChildType) { return ChildList(*ChildType); };
        MDObjectPtr operator[](MDOTypePtr ChildType);
        MDObjectPtr Child(MDOTypePtr ChildType) { return operator[](ChildType); };
        MDObjectListPtr ChildList(MDOTypePtr ChildType);
        MDObjectPtr operator[](const UL &ChildType);
        MDObjectPtr operator[](ULPtr &ChildType) { return operator[](*ChildType); };
        MDObjectPtr Child(const UL &ChildType) { return operator[](ChildType); };
        MDObjectPtr Child(ULPtr &ChildType) { return operator[](*ChildType); };
        MDObjectListPtr ChildList(ULPtr &ChildType);

        void SetInt(Int32 Val) { SetModified(true); if (Value) Value->SetInt(Val); };
        void SetInt64(Int64 Val) { SetModified(true); if (Value) Value->SetInt64(Val); };
        void SetUInt(UInt32 Val) { SetModified(true); if (Value) Value->SetUInt(Val); };
        void SetUInt64(UInt64 Val) { SetModified(true); if (Value) Value->SetUInt64(Val); };
        void SetUint(UInt32 Val) { SetUInt(Val); }
        void SetUint64(UInt64 Val) { SetUInt64(Val); }
        void SetString(std::string Val) { SetModified(true); if (Value) Value->SetString(Val); };
        bool SetDValue(void);
        void SetValue(const DataChunk &Source) { ReadValue(Source); }
        void SetValue(MDObjectPtr Source) { ReadValue(Source->Value->PutData()); }
        Int32 GetInt(Int32 Default = 0) { if (Value) return Value->GetInt(); else return Default; };
        Int64 GetInt64(Int64 Default = 0) { if (Value) return Value->GetInt64(); else return Default; };
        UInt32 GetUInt(UInt32 Default = 0) { if (Value) return Value->GetUInt(); else return Default; };
        UInt64 GetUInt64(UInt64 Default = 0) { if(Value) return Value->GetUInt64(); else return Default; };
        UInt32 GetUint(UInt32 Default = 0) { return GetUInt(Default); }
        UInt64 GetUint64(UInt64 Default = 0) { return GetUInt64(Default); }
        std::string GetString(std::string Default = "") { if(Value) return Value->GetString(); else return Default; };
        bool IsDValue(void);


        bool SetDefault(void)
        {
            if(!Value) return false;

            ASSERT(Type);

            if(Type->GetDefault().Size == 0) return false;

            Value->ReadValue(Type->GetDefault());

            return true;
        }


        /* Child value access */
        // For set functions AddChild is used (without replace option)
        // to ensure that the child exists and to set the modified flag
        void SetInt(const char *ChildName, Int32 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName);
            if (Ptr) Ptr->SetInt(Val); 
            else if(Value) { SetModified(true); Value->SetInt(ChildName, Val); }
        };
        void SetInt64(const char *ChildName, Int64 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName);
            if (Ptr) Ptr->SetInt64(Val);
            else if(Value) { SetModified(true); Value->SetInt64(ChildName, Val); }
        };
        void SetUInt(const char *ChildName, UInt32 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName);
            if (Ptr) Ptr->SetUInt(Val);
            else if(Value) { SetModified(true); Value->SetUInt(ChildName, Val); }
        };
        void SetUInt64(const char *ChildName, UInt64 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName);
            if (Ptr) Ptr->SetUInt64(Val);
            else if(Value) { SetModified(true); Value->SetUInt64(ChildName, Val); }
        };
        void SetUint(const char *ChildName, UInt32 Val) { SetUInt(ChildName, Val); }
        void SetUint64(const char *ChildName, UInt64 Val) { SetUInt64(ChildName, Val); }

        void SetString(const char *ChildName, std::string Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName);
            if (Ptr) Ptr->SetString(Val);
            else if(Value) { SetModified(true); Value->SetString(ChildName, Val); }
        };

        bool SetDValue(const char *ChildName) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName); 
            if (Ptr) return Ptr->SetDValue(); else return false; 
        };
        
        void SetValue(const char *ChildName, const DataChunk &Source) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName); 
            if (Ptr) Ptr->ReadValue(Source); 
            else if(Value) { SetModified(true); Value->ReadValue(ChildName, Source); }
        };

        void SetValue(const char *ChildName, MDObjectPtr Source) 
        { 
            MDObjectPtr Ptr = AddChild(ChildName); 
            if (Ptr) Ptr->ReadValue(Source->Value->PutData());
            else if(Value) { SetModified(true); Value->ReadValue(ChildName, Source->Value->PutData()); }
        };

        Int32 GetInt(const char *ChildName, Int32 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildName);
            if (Ptr) return Ptr->GetInt(); else if(Value) return Value->GetInt(ChildName, Default); else return Default; 
        };

        Int64 GetInt64(const char *ChildName, Int64 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildName); 
            if (Ptr) return Ptr->GetInt64(); else if(Value) return Value->GetInt64(ChildName, Default); else return Default; 
        };

        UInt32 GetUInt(const char *ChildName, UInt32 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildName); 
            if (Ptr) return Ptr->GetUInt(); else if(Value) return Value->GetUInt(ChildName, Default); else return Default; 
        };

        UInt64 GetUInt64(const char *ChildName, UInt64 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildName); 
            if (Ptr) return Ptr->GetUInt64(); else if(Value) return Value->GetUInt64(ChildName, Default); else return Default; 
        };

        UInt32 GetUint(const char *ChildName, UInt32 Default = 0) { return GetUInt(ChildName, Default); }
        UInt64 GetUint64(const char *ChildName, UInt64 Default = 0)  { return GetUInt64(ChildName, Default); }

        std::string GetString(const char *ChildName, std::string Default = "")
        { 
            MDObjectPtr Ptr = operator[](ChildName); 
            if (Ptr) return Ptr->GetString(); else if(Value) return Value->GetString(ChildName, Default); else return Default; 
        };

        bool IsDValue(const char *ChildName) 
        { 
            MDObjectPtr Ptr = operator[](ChildName);
            if (Ptr) return Ptr->IsDValue(); else return false; 
        };

        void SetInt(const UL &ChildType, Int32 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType);
            if (Ptr) Ptr->SetInt(Val);
        };
        void SetInt(ULPtr &ChildType, Int32 Val) { SetInt(*ChildType, Val); }

        void SetInt64(const UL &ChildType, Int64 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType);
            if (Ptr) Ptr->SetInt64(Val);
        };
        void SetInt64(ULPtr &ChildType, Int64 Val) { SetInt64(*ChildType, Val); }

        void SetUInt(const UL &ChildType, UInt32 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType);
            if (Ptr) Ptr->SetUInt(Val);
        };
        void SetUInt(ULPtr &ChildType, UInt32 Val) { SetUInt(*ChildType, Val); }

        void SetUInt64(const UL &ChildType, UInt64 Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType);
            if (Ptr) Ptr->SetUInt64(Val);
        };
        void SetUInt64(ULPtr &ChildType, UInt64 Val) { SetUInt64(*ChildType, Val); }

        void SetString(const UL &ChildType, std::string Val) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType);
            if (Ptr) Ptr->SetString(Val);
        };
        void SetString(ULPtr &ChildType, std::string Val) { SetString(*ChildType, Val); }

        bool SetDValue(const UL &ChildType) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType); 
            if (Ptr) return Ptr->SetDValue(); else return false;
        };
        bool SetDValue(ULPtr &ChildType) { return SetDValue(*ChildType); }
        
        void SetValue(const UL &ChildType, const DataChunk &Source) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType); 
            if (Ptr) Ptr->ReadValue(Source);
        };
        void SetValue(ULPtr &ChildType, const DataChunk &Source) { SetValue(*ChildType, Source); }

        void SetValue(const UL &ChildType, MDObjectPtr Source) 
        { 
            MDObjectPtr Ptr = AddChild(ChildType); 
            if (Ptr) Ptr->ReadValue(Source->Value->PutData());
        };
        void SetValue(ULPtr &ChildType, MDObjectPtr Source) { SetValue(*ChildType, Source); }
        
        Int32 GetInt(const UL &ChildType, Int32 Default = 0)
        { 
            MDObjectPtr Ptr = operator[](ChildType);
            if (Ptr) return Ptr->GetInt(); else return Default;
        };
        Int32 GetInt(ULPtr &ChildType, Int32 Default = 0) { return GetInt(*ChildType, Default); }

        Int64 GetInt64(const UL &ChildType, Int64 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildType); 
            if (Ptr) return Ptr->GetInt64(); else return Default;
        };
        Int64 GetInt64(ULPtr &ChildType, Int64 Default = 0) { return GetInt64(*ChildType, Default); }

        UInt32 GetUInt(const UL &ChildType, UInt32 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildType); 
            if (Ptr) return Ptr->GetUInt(); else return Default;
        };
        UInt32 GetUInt(ULPtr &ChildType, UInt32 Default = 0) { return GetUInt(*ChildType, Default); }

        UInt64 GetUInt64(const UL &ChildType, UInt64 Default = 0) 
        { 
            MDObjectPtr Ptr = operator[](ChildType); 
            if (Ptr) return Ptr->GetUInt64(); else return Default;
        };
        UInt64 GetUInt64(ULPtr &ChildType, UInt64 Default = 0) { return GetUInt64(*ChildType, Default); }

        std::string GetString(const UL &ChildType, std::string Default = "")
        { 
            MDObjectPtr Ptr = operator[](ChildType); 
            if (Ptr) return Ptr->GetString(); else return Default;
        };
        std::string GetString(ULPtr &ChildType, std::string Default = "") { return GetString(*ChildType, Default); }

        bool IsDValue(const UL &ChildType) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->IsDValue(); else return false; };
        bool IsDValue(ULPtr &ChildType) { return IsDValue(*ChildType); }

        void SetInt(MDOTypePtr ChildType, Int32 Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetInt(Val); };
        void SetInt64(MDOTypePtr ChildType, Int64 Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetInt64(Val); };
        void SetUInt(MDOTypePtr ChildType, UInt32 Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetUInt(Val); };
        void SetUInt64(MDOTypePtr ChildType, UInt64 Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetUInt64(Val); };
        void SetUint(MDOTypePtr ChildType, UInt32 Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetUInt(Val); };
        void SetUint64(MDOTypePtr ChildType, UInt64 Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetUInt64(Val); };
        void SetString(MDOTypePtr ChildType, std::string Val) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->SetString(Val); };
        bool SetDValue(MDOTypePtr ChildType) { MDObjectPtr Ptr = AddChild(ChildType); if (Ptr) return Ptr->SetDValue(); else return false; };
        void SetValue(MDOTypePtr ChildType, MDObjectPtr Source) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->ReadValue(Source->Value->PutData()); }
        void SetValue(MDOTypePtr ChildType, const DataChunk &Source) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) Ptr->ReadValue(Source); }
        Int32 GetInt(MDOTypePtr ChildType, Int32 Default = 0) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetInt(); else return Default; };
        Int64 GetInt64(MDOTypePtr ChildType, Int64 Default = 0) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetInt64(); else return Default; };
        UInt32 GetUInt(MDOTypePtr ChildType, UInt32 Default = 0) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetUInt(); else return Default; };
        UInt64 GetUInt64(MDOTypePtr ChildType, UInt64 Default = 0) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetUInt64(); else return Default; };
        UInt32 GetUint(MDOTypePtr ChildType, UInt32 Default = 0) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetUInt(); else return Default; };
        UInt64 GetUint64(MDOTypePtr ChildType, UInt64 Default = 0) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetUInt64(); else return Default; };
        std::string GetString(MDOTypePtr ChildType, std::string Default = "") { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->GetString(); else return Default; };
        bool IsDValue(MDOTypePtr ChildType) { MDObjectPtr Ptr = operator[](ChildType); if (Ptr) return Ptr->IsDValue(); else return false; };

        /* Child raw data access */
        const DataChunk& GetData(void) { ASSERT(Value); return Value->GetData(); };

        const DataChunkPtr PutData(PrimerPtr UsePrimer = NULL);

        size_t ReadValue(const DataChunk &Chunk) { return ReadValue(Chunk.Data, Chunk.Size); };

        size_t ReadValue(DataChunkPtr &Chunk) { return ReadValue(Chunk->Data, Chunk->Size); };

        size_t ReadValue(const UInt8 *Buffer, size_t Size, PrimerPtr UsePrimer = NULL);

        DataChunkPtr WriteObject(MDObjectPtr ParentObject, PrimerPtr UsePrimer, UInt32 BERSize = 0)
        {
            DataChunkPtr Ret = new DataChunk;
            WriteObject(Ret, ParentObject, UsePrimer, BERSize);
            return Ret;
        }

        size_t WriteObject(DataChunkPtr &Buffer, MDObjectPtr ParentObject, PrimerPtr UsePrimer, UInt32 BERSize = 0);


        DataChunkPtr WriteObject(PrimerPtr UsePrimer = NULL, UInt32 BERSize = 0)
        {
            DataChunkPtr Ret = new DataChunk;
            WriteObject(Ret, NULL, UsePrimer, BERSize);
            return Ret;
        }


        size_t WriteObject(DataChunkPtr &Buffer, PrimerPtr UsePrimer = NULL, UInt32 BERSize = 0)
        {
            return WriteObject(Buffer, NULL, UsePrimer, BERSize);
        }

        size_t WriteLinkedObjects(DataChunkPtr &Buffer, PrimerPtr UsePrimer = NULL);

        std::string Name(void) const { return ObjectName; };

        std::string FullName(void) const 
        {
            if(Parent) return Parent->FullName() + "/" + ObjectName;
            else return ObjectName; 
        };

        void insert(MDObjectPtr NewObject)
        {
            if(NewObject->TheUL)
                push_back(MDObjectULList::value_type(*(NewObject->TheUL), NewObject));
            else
                ASSERT(0);
//              push_back(MDObjectULList::value_type(Null_UL, NewObject));
        }

        const MDOTypePtr &GetType(void) const { return Type; };

        bool IsA(std::string BaseType);

        bool IsA(MDOTypePtr &BaseType);
        
        bool IsA(const UL &BaseType);

        bool IsA(ULPtr &BaseType) { return IsA(*BaseType); }

        MDObjectPtr GetLink(void) const { return Link; };

        bool MakeRef(MDObjectPtr &TargetSet, bool ForceLink = false);
    

        bool MakeLink(MDObjectPtr &TargetSet, bool ForceLink = false) { return MakeRef(TargetSet, ForceLink); }
    
        void SetLink(MDObjectPtr NewLink) { Link = NewLink; };

        ClassRef GetRefType(void) const { ASSERT(Type); return Type->GetRefType(); };

        MDOTypePtr GetRefTarget(void) const { if(Type) return Type->GetRefTarget(); else return NULL; };

        void SetParent(MXFFilePtr &File, UInt64 Location, UInt32 NewKLSize)
        {
            IsConstructed = false;
            ParentOffset = Location;
            KLSize = NewKLSize;
            Parent = NULL;
            ParentFile = File;
        }

        void SetParent(MDObjectPtr &Object, UInt64 Location, UInt32 NewKLSize)
        {
            IsConstructed = false;
            ParentOffset = Location;
            KLSize = NewKLSize;
            Parent = Object;
            ParentFile = NULL;
        }

        MDObjectParent &GetParent(void) { return Parent; }

        MXFFilePtr &GetParentFile(void) { return ParentFile; };

        const ULPtr &GetUL(void) { return TheUL; }

        void SetUL(ULPtr &NewUL) { TheUL = NewUL; }

        void SetTag(Tag NewTag) { TheTag = NewTag; }

        Tag GetTag(void) { return TheTag; }


        bool ChangeType(const UL &NewType)
        {
            MDOTypePtr Ptr = MDOType::Find(NewType);

            if(!Ptr) return false;

            Type = Ptr;
            ObjectName = Type->Name();
            TheUL = Type->GetUL();
            if(TheUL) TheTag = MDOType::GetStaticPrimer()->Lookup(TheUL);
            else TheTag = 0;

            return true;
        }


        bool ChangeType(ULPtr &NewType) { return ChangeType(*NewType); }


        bool ChangeType(std::string NewType)
        {
            MDOTypePtr Ptr = MDOType::Find(NewType);

            if(!Ptr) return false;

            Type = Ptr;
            ObjectName = Type->Name();
            TheUL = Type->GetUL();
            if(TheUL) TheTag = MDOType::GetStaticPrimer()->Lookup(TheUL);
            else TheTag = 0;

            return true;
        }

        MDObjectPtr MakeCopy(void);

    protected:

        void SetModified(bool State) { Modified = State; }

    public:

        bool SetGenerationUID(UUIDPtr UID);

        bool IsModified(void);

        void ClearModified(void);

        UInt64 GetLocation(void);

        std::string GetSource(void);

        std::string GetSourceLocation(void) 
        {
            return std::string("0x") + Int64toHexString(GetLocation(),8) + std::string(" in ") + GetSource();
        }

        ObjectInterface *GetOuter(void) { return Outer; };

        void SetOuter(ObjectInterface *NewOuter) { Outer = NewOuter; };

    public:
        static void SetULTranslator(ULTranslator Trans) { UL2NameFunc = Trans; }

        static void SetParseDark(bool Value) { ParseDark = Value; }

    protected:
        // Some private helper functions
        static UInt32 ReadKey(DictKeyFormat Format, size_t Size, const UInt8 *Buffer, DataChunk& Key);
        static UInt32 ReadLength(DictLenFormat Format, size_t Size, const UInt8 *Buffer, Length& Length);
        UInt32 WriteKey(DataChunkPtr &Buffer, DictKeyFormat Format, PrimerPtr UsePrimer = NULL);
        static UInt32 WriteLength(DataChunkPtr &Buffer, Length Length, DictLenFormat Format, UInt32 Size = 0);
    };
}


namespace mxflib
{

    class ObjectInterface
    {
    protected:
        ObjectInterface(MDObjectPtr BaseObject) : Object(BaseObject) {}

    public:
        MDObjectPtr Object;                 

    public:
        ObjectInterface() {};               
        virtual ~ObjectInterface() {};      
        
        // ** MDObject Interface **
        std::string Name(void) const { return Object->Name(); };
        std::string FullName(void) const { return Object->FullName(); };

        MDObjectPtr operator[](std::string ChildName) { return Object->operator[](ChildName); };
        MDObjectPtr Child(std::string ChildName) { return Object->operator[](ChildName); };
        MDObjectListPtr ChildList(std::string ChildName) { return Object->ChildList(ChildName); };
        
        MDObjectPtr operator[](const UL &ChildType) { return Object->operator[](ChildType); };
        MDObjectPtr Child(const UL &ChildType) { return Object->operator[](ChildType); };
        MDObjectListPtr ChildList(const UL &ChildType) { return Object->ChildList(ChildType); };
        
        MDObjectPtr operator[](ULPtr &ChildType) { return Object->operator[](*ChildType); };
        MDObjectPtr Child(ULPtr &ChildType) { return Object->operator[](*ChildType); };
        MDObjectListPtr ChildList(ULPtr &ChildType) { return Object->ChildList(*ChildType); };

        MDObjectPtr operator[](MDOTypePtr ChildType) { return Object->operator[](ChildType); };
        MDObjectPtr Child(MDOTypePtr ChildType) { return Object->operator[](ChildType); };
        MDObjectListPtr ChildList(MDOTypePtr ChildType) { return Object->ChildList(ChildType); };

        MDObjectPtr AddChild(void) { return Object->AddChild(); }
        MDObjectPtr AddChild(std::string ChildName, bool Replace = true) { return Object->AddChild(ChildName, Replace); };
        MDObjectPtr AddChild(MDObjectPtr ChildObject, bool Replace = false) { return Object->AddChild(ChildObject, Replace); };
        MDObjectPtr AddChild(const UL &ChildType, bool Replace = true) { return Object->AddChild(ChildType, Replace); };
        MDObjectPtr AddChild(ULPtr &ChildType, bool Replace = true) { return Object->AddChild(*ChildType, Replace); };

        void RemoveChild(std::string ChildName) { Object->RemoveChild(ChildName); };
        void RemoveChild(MDOTypePtr ChildType) { Object->RemoveChild(ChildType); };
        void RemoveChild(MDObjectPtr ChildObject) { Object->RemoveChild(ChildObject); };

        void SetInt(const char *ChildName, Int32 Val) { Object->SetInt(ChildName, Val); };
        void SetInt64(const char *ChildName, Int64 Val) { Object->SetInt64(ChildName, Val); };
        void SetUInt(const char *ChildName, UInt32 Val) { Object->SetUInt(ChildName, Val); };
        void SetUInt64(const char *ChildName, UInt64 Val) { Object->SetUInt64(ChildName, Val); };
        void SetUint(const char *ChildName, UInt32 Val) { Object->SetUInt(ChildName, Val); };
        void SetUint64(const char *ChildName, UInt64 Val) { Object->SetUInt64(ChildName, Val); };
        void SetString(const char *ChildName, std::string Val) { Object->SetString(ChildName, Val); };
        bool SetDValue(const char *ChildName) { return Object->SetDValue(ChildName); };
        void SetValue(const char *ChildName, const DataChunk &Source) { Object->SetValue(ChildName, Source); }
        void SetValue(const char *ChildName, MDObjectPtr Source) { Object->SetValue(ChildName, Source); }
        Int32 GetInt(const char *ChildName, Int32 Default = 0) { return Object->GetInt(ChildName, Default); };
        Int64 GetInt64(const char *ChildName, Int64 Default = 0) { return Object->GetInt64(ChildName, Default); };
        UInt32 GetUInt(const char *ChildName, UInt32 Default = 0) { return Object->GetUInt(ChildName, Default); };
        UInt64 GetUInt64(const char *ChildName, UInt64 Default = 0) { return Object->GetUInt64(ChildName, Default); };
        UInt32 GetUint(const char *ChildName, UInt32 Default = 0) { return Object->GetUInt(ChildName, Default); };
        UInt64 GetUint64(const char *ChildName, UInt64 Default = 0) { return Object->GetUInt64(ChildName, Default); };
        std::string GetString(const char *ChildName, std::string Default = "") { return Object->GetString(ChildName, Default); };
        bool IsDValue(const char *ChildName) { return Object->IsDValue(ChildName); };
        
        void SetInt(const UL &ChildType, Int32 Val) { Object->SetInt(ChildType, Val); };
        void SetInt(ULPtr &ChildType, Int32 Val) { Object->SetInt(*ChildType, Val); };
        void SetInt64(const UL &ChildType, Int64 Val) { Object->SetInt64(ChildType, Val); };
        void SetInt64(ULPtr &ChildType, Int64 Val) { Object->SetInt64(*ChildType, Val); };
        void SetUInt(const UL &ChildType, UInt32 Val) { Object->SetUInt(ChildType, Val); };
        void SetUInt(ULPtr &ChildType, UInt32 Val) { Object->SetUInt(*ChildType, Val); };
        void SetUInt64(const UL &ChildType, UInt64 Val) { Object->SetUInt64(ChildType, Val); };
        void SetUInt64(ULPtr &ChildType, UInt64 Val) { Object->SetUInt64(*ChildType, Val); };
        void SetString(const UL &ChildType, std::string Val) { Object->SetString(ChildType, Val); };
        void SetString(ULPtr &ChildType, std::string Val) { Object->SetString(*ChildType, Val); };
        bool SetDValue(const UL &ChildType) { return Object->SetDValue(ChildType); };
        bool SetDValue(ULPtr &ChildType) { return Object->SetDValue(*ChildType); };
        void SetValue(const UL &ChildType, const DataChunk &Source) { Object->SetValue(ChildType, Source); }
        void SetValue(ULPtr &ChildType, const DataChunk &Source) { Object->SetValue(*ChildType, Source); }
        void SetValue(const UL &ChildType, MDObjectPtr Source) { Object->SetValue(ChildType, Source); }
        void SetValue(ULPtr &ChildType, MDObjectPtr Source) { Object->SetValue(*ChildType, Source); }
        Int32 GetInt(const UL &ChildType, Int32 Default = 0) { return Object->GetInt(ChildType, Default); };
        Int32 GetInt(ULPtr &ChildType, Int32 Default = 0) { return Object->GetInt(*ChildType, Default); };
        Int64 GetInt64(const UL &ChildType, Int64 Default = 0) { return Object->GetInt64(ChildType, Default); };
        Int64 GetInt64(ULPtr &ChildType, Int64 Default = 0) { return Object->GetInt64(*ChildType, Default); };
        UInt32 GetUInt(const UL &ChildType, UInt32 Default = 0) { return Object->GetUInt(ChildType, Default); };
        UInt32 GetUInt(ULPtr &ChildType, UInt32 Default = 0) { return Object->GetUInt(*ChildType, Default); };
        UInt64 GetUInt64(const UL &ChildType, UInt64 Default = 0) { return Object->GetUInt64(ChildType, Default); };
        UInt64 GetUInt64(ULPtr &ChildType, UInt64 Default = 0) { return Object->GetUInt64(*ChildType, Default); };
        std::string GetString(const UL &ChildType, std::string Default = "") { return Object->GetString(ChildType, Default); };
        std::string GetString(ULPtr &ChildType, std::string Default = "") { return Object->GetString(*ChildType, Default); };
        bool IsDValue(const UL &ChildType) { return Object->IsDValue(ChildType); };
        bool IsDValue(ULPtr &ChildType) { return Object->IsDValue(*ChildType); };

        void SetInt(MDOTypePtr ChildType, Int32 Val) { Object->SetInt(ChildType, Val); };
        void SetInt64(MDOTypePtr ChildType, Int64 Val) { Object->SetInt64(ChildType, Val); };
        void SetUInt(MDOTypePtr ChildType, UInt32 Val) { Object->SetUInt(ChildType, Val); };
        void SetUInt64(MDOTypePtr ChildType, UInt64 Val) { Object->SetUInt64(ChildType, Val); };
        void SetUint(MDOTypePtr ChildType, UInt32 Val) { Object->SetUInt(ChildType, Val); };
        void SetUint64(MDOTypePtr ChildType, UInt64 Val) { Object->SetUInt64(ChildType, Val); };
        void SetString(MDOTypePtr ChildType, std::string Val) { Object->SetString(ChildType, Val); };
        bool SetDValue(MDOTypePtr ChildType) { return Object->SetDValue(ChildType); };
        void SetValue(MDOTypePtr ChildType, const DataChunk &Source) { Object->SetValue(ChildType, Source); }
        void SetValue(MDOTypePtr ChildType, MDObjectPtr Source) { Object->SetValue(ChildType, Source); }
        Int32 GetInt(MDOTypePtr ChildType, Int32 Default = 0) { return Object->GetInt(ChildType, Default); };
        Int64 GetInt64(MDOTypePtr ChildType, Int64 Default = 0) { return Object->GetInt64(ChildType, Default); };
        UInt32 GetUInt(MDOTypePtr ChildType, UInt32 Default = 0) { return Object->GetUInt(ChildType, Default); };
        UInt64 GetUInt64(MDOTypePtr ChildType, UInt64 Default = 0) { return Object->GetUInt64(ChildType, Default); };
        UInt32 GetUint(MDOTypePtr ChildType, UInt32 Default = 0) { return Object->GetUInt(ChildType, Default); };
        UInt64 GetUint64(MDOTypePtr ChildType, UInt64 Default = 0) { return Object->GetUInt64(ChildType, Default); };
        std::string GetString(MDOTypePtr ChildType, std::string Default = "") { return Object->GetString(ChildType, Default); };
        bool IsDValue(MDOTypePtr ChildType) { return Object->IsDValue(ChildType); };

        const DataChunk& GetData(void) { ASSERT(Object); return Object->GetData(); };

        DataChunkPtr PutData(PrimerPtr UsePrimer = NULL) { if(Object) return Object->PutData(UsePrimer); else return new DataChunk(); };

        size_t ReadValue(const DataChunk &Chunk) { return Object->ReadValue(Chunk.Data, Chunk.Size); };

        size_t ReadValue(const DataChunkPtr &Chunk) { return Object->ReadValue(Chunk->Data, Chunk->Size); };

        size_t ReadValue(const UInt8 *Buffer, size_t Size, PrimerPtr UsePrimer = NULL) { return Object->ReadValue(Buffer, Size, UsePrimer); };

        DataChunkPtr WriteObject(MDObjectPtr ParentObject, PrimerPtr UsePrimer) { return Object->WriteObject(ParentObject, UsePrimer); };

        size_t WriteObject(DataChunkPtr &Buffer, MDObjectPtr ParentObject, PrimerPtr UsePrimer) { return Object->WriteObject(Buffer, ParentObject, UsePrimer); };


        DataChunkPtr WriteObject(PrimerPtr UsePrimer = NULL)
        {
            return Object->WriteObject(NULL, UsePrimer);
        }


        size_t WriteObject(DataChunkPtr &Buffer, PrimerPtr UsePrimer = NULL)
        {
            return Object->WriteObject(Buffer, NULL, UsePrimer);
        }

        MDOTypePtr GetType(void) const { return Object->GetType(); };
        MDObjectPtr GetLink(void) const { return Object->GetLink(); };
        void SetLink(MDObjectPtr NewLink) { Object->SetLink(NewLink); };
        ClassRef GetRefType(void) const { return Object->GetRefType(); };

        bool IsA(std::string BaseType) { return Object->IsA(BaseType); }

        bool IsA(MDOTypePtr BaseType) { return Object->IsA(BaseType); }

        bool IsA(const UL &BaseType) { return Object->IsA(BaseType); }

        bool IsA(ULPtr &BaseType) { return Object->IsA(*BaseType); }

        void SetParent(MXFFilePtr File, UInt64 Location, UInt32 NewKLSize) { Object->SetParent(File, Location, NewKLSize); };

        void SetParent(MDObjectPtr ParentObject, UInt64 Location, UInt32 NewKLSize) { Object->SetParent(ParentObject, Location, NewKLSize); };

        bool IsModified(void) { return Object->IsModified(); }

        void ClearModified(void) { Object->ClearModified(); }

        UInt64 GetLocation(void) { return Object->GetLocation(); }
        std::string GetSource(void) { return Object->GetSource(); }
        std::string GetSourceLocation(void) { return Object->GetSourceLocation(); }


        bool ChangeType(std::string NewType) { return Object->ChangeType(NewType); };


        bool ChangeType(const UL &NewType) { return Object->ChangeType(NewType); }


        bool ChangeType(ULPtr &NewType) { return Object->ChangeType(*NewType); }

    };
}


// These simple inlines need to be defined after MDObject
namespace mxflib
{
inline MDObjectPtr MDObjectPtr::operator[](const char *ChildName) { return GetPtr()->operator[](ChildName); }
inline MDObjectPtr MDObjectPtr::operator[](MDOTypePtr &ChildType) { return GetPtr()->operator[](ChildType); }
inline MDObjectPtr MDObjectPtr::operator[](const UL &ChildType) { return GetPtr()->operator[](ChildType); }
inline MDObjectPtr MDObjectPtr::operator[](ULPtr &ChildType) { return GetPtr()->operator[](ChildType); }
inline MDObjectPtr MDObjectParent::operator[](const char *ChildName) { return GetPtr()->operator[](ChildName); }
inline MDObjectPtr MDObjectParent::operator[](MDOTypePtr &ChildType) { return GetPtr()->operator[](ChildType); }
inline MDObjectPtr MDObjectParent::operator[](const UL &ChildType) { return GetPtr()->operator[](ChildType); }
inline MDObjectPtr MDObjectParent::operator[](ULPtr &ChildType) { return GetPtr()->operator[](ChildType); }
}

#endif // MXFLIB__MDOBJECT_H

---