mdtype.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003, Matt Beard
 *
 *  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__MDTYPE_H
#define MXFLIB__MDTYPE_H

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

namespace mxflib
{
    typedef std::list<std::string> StringList;
}

namespace mxflib
{
    enum MDContainerType                
    { 
        NONE,                           
        SET,                            
        PACK,                           
        BATCH,                          
        ARRAY                           
    };
    enum MDTypeClass                    
    { 
        BASIC,                          
        INTERPRETATION,                 
        TYPEARRAY,                      
        COMPOUND,                       
        ENUM                            
    };
    enum MDArrayClass                   
    {
        ARRAYARRAY,                     
        ARRAYBATCH                      
    };
}


namespace mxflib
{

    class MapIndex
    {
    public:
        bool IsNum;
        UInt32 Number;
        std::string String;

    public:
//      MapIndex() { ASSERT(0); };
        MapIndex(UInt32 Num) { IsNum = true; Number = Num; String = Int2String(Num); };
        MapIndex(std::string Str) { IsNum = false; String = Str; };
        MapIndex(const MapIndex& Map) 
        { IsNum = Map.IsNum; 
            if(IsNum) Number = Map.Number; 
            String = Map.String; 
        };

        bool operator<(const MapIndex& Other) const
        {
            if((IsNum==true) && (Other.IsNum==true)) return (Number < Other.Number);
            if((IsNum==false) && (Other.IsNum==false)) return (String < Other.String);
            
            // Numbers come before strings
            return Other.IsNum;
        }

        MapIndex& operator=(UInt32 Num) 
        { 
            if(IsNum) { Number = Num; String = Int2String(Num); } 
            return *this;
        };

        MapIndex& operator=(std::string Str) 
        { 
            if(IsNum) 
            {
                Number = atoi(Str.c_str());
                String = Int2String(Number);        // Reformat the string
            }
            else
            {
                String = Str;
            }
            return *this;
        };

        MapIndex& operator=(const MapIndex& Map)
        { 
            if(IsNum)
            {
                Number = atoi(Map.String.c_str());  // Will be zero in !Map.IsNum
                String = Int2String(Number);        // Reformat the string
            }
            else
            {
                String = Map.String;
            }
            return *this;
        };

        const char *c_str() const
        {
            return (const char *)String.c_str();
        }

        bool operator==(const MapIndex& Other) const
        {
            if(Other.IsNum != IsNum) return false;
            if(IsNum) return (Number == Other.Number);
            return (String == Other.String);
        }
    };
}


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

    typedef SmartPtr<MDType> MDTypePtr;

    typedef ParentPtr<MDType> MDTypeParent;

    typedef std::list<MDTypePtr> MDTypeList;

//  typedef std::pair<MDTypePtr, std::string> MDNamedType;
//  typedef std::list<MDNamedType> MDNamedTypeList;

    typedef std::map<std::string, MDTypePtr> MDTypeMap;
}


namespace mxflib
{
    class MDType : public RefCount<MDType> , public MDTypeMap
    {
    protected:
        std::string TypeName;           
        MDTypeClass Class;              
        MDArrayClass ArrayClass;        
        MDTraitsPtr Traits;             
        ULPtr TypeUL;                   
        bool Endian;                    
        TypeRef RefType;                
        std::string RefTarget;          

    public:
        typedef std::pair<std::string, MDValuePtr> NamedValue;

        typedef std::list<NamedValue> NamedValueList;

    protected:
        NamedValueList EnumValues;      

    public:
        MDTypeParent Base;                  
//      MDTypeList Children;            //!< Types contained in this if it is a compound
        StringList ChildOrder;          
        int Size;                       

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

    protected:

        MDType(std::string TypeName, MDTypeClass TypeClass, ULPtr &UL, MDTraitsPtr TypeTraits)
            : TypeName(TypeName), Class(TypeClass), ArrayClass(ARRAYARRAY), Traits(TypeTraits), TypeUL(UL), Endian(false),
              RefType(TypeRefUndefined)
        { };
 
        MDType();

        MDType(const MDType &rhs);

        void AddSub(std::string SubName, MDTypePtr SubType);

    public:
        MDTypePtr EffectiveType(void);

        MDTypeClass EffectiveClass(void) const;

        MDTypePtr EffectiveBase(void) const;

        TypeRef EffectiveRefType(void) const;

        std::string EffectiveRefTarget(void) const;


        UInt32 EffectiveSize(void) const;


        bool HandlesSubdata(void) const
        {
            if(Traits) return Traits->HandlesSubdata();
            return false;
        }

        void SetEndian(bool Val) { Endian = Val; };

        bool GetEndian(void) const { return Endian; };

        void SetArrayClass(MDArrayClass Val) { ArrayClass = Val; };

        MDArrayClass GetArrayClass(void) { return ArrayClass; };

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

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

        NamedValueList &GetEnumValues(void) { return EnumValues; }

        void SetRefType(TypeRef Val) { RefType = Val; }

        TypeRef GetRefType(void) const { return RefType; }

        void SetRefTarget(std::string Val) { RefTarget = Val; }

        std::string GetRefTarget(void) const { return RefTarget; }


    //** Static Dictionary Handling data and functions **
    //***************************************************
    protected:
        static MDTypeList Types;        

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

        static MDTypeMap NameLookup;

    public:
        static MDTypePtr AddBasic(std::string TypeName, ULPtr &UL, int TypeSize);

        static MDTypePtr AddInterpretation(std::string TypeName, MDTypePtr BaseType, ULPtr &UL, int Size = 0);

        static MDTypePtr AddArray(std::string TypeName, MDTypePtr BaseType, ULPtr &UL, int ArraySize = 0);

        static MDTypePtr AddCompound(std::string TypeName, ULPtr &UL);

        static MDTypePtr AddEnum(std::string TypeName, MDTypePtr BaseType, ULPtr &UL);

        bool AddEnumValue(std::string Name, MDValuePtr &Value);

        bool AddEnumValue(std::string Name, std::string Value);

        bool AddEnumValue(std::string Name, ULPtr &Value);

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

        static MDTypePtr Find(const UL &BaseUL);

        static MDTypePtr Find(ULPtr &BaseUL) { return Find(*BaseUL); }


    /* Traits handling */
    /*******************/

    public:
        void SetTraits(MDTraitsPtr Tr) 
        { 
            Traits = Tr; 
        };

        MDTraitsPtr GetTraits(void) const { return Traits; };

    protected:
        typedef std::map<std::string, MDTraitsPtr> TraitsMapType;

        static TraitsMapType TraitsMap;

        typedef std::map<UL, MDTraitsPtr> TraitsULMapType;

        static TraitsULMapType TraitsULMap;

    protected:
        static void AddType(MDTypePtr &Type, ULPtr &TypeUL);

    public:

        static bool AddTraitsMapping(std::string TypeName, std::string TraitsName);

        static bool UpdateTraitsMapping(std::string TypeName, std::string TraitsName)
        {
            // DRAGONS: For the moment this does exactly the same ass AddTraitsMapping - it may differ in future versions
            return AddTraitsMapping(TypeName, TraitsName);
        }


        static bool AddTraitsMapping(const UL &TypeUL, std::string TraitsName);

        static bool UpdateTraitsMapping(const UL &TypeUL, std::string TraitsName)
        {
            // DRAGONS: For the moment this does exactly the same ass AddTraitsMapping - it may differ in future versions
            return AddTraitsMapping(TypeUL, TraitsName);
        }


        static MDTraitsPtr LookupTraitsMapping(std::string TypeName, std::string DefaultTraitsName = "");


        static MDTraitsPtr LookupTraitsMapping(const UL &TypeUL, const UL &DefaultTraitsUL);


        static MDTraitsPtr LookupTraitsMapping(std::string TypeName, const UL &DefaultTraitsUL);


        static MDTraitsPtr LookupTraitsMapping(const UL &TypeUL, std::string DefaultTraitsName = "");

        /* Allow MDValue class to view internals of this class */
        friend class MDValue;
    };
}

namespace mxflib
{

    /*template<class C>*/ inline std::string AddTraitsMapping(std::string TypeName, MDTraitsPtr Tr)
    {
//      MDTraitsPtr Tr = new C;
        MDTraitsPtr TrLookup = MDTraits::Find(Tr->Name());

        if(!TrLookup) MDTraits::Add(Tr->Name(), Tr);

        if(MDType::AddTraitsMapping(TypeName, Tr->Name()))
            return Tr->Name();
        else
            return "";
    }



    /*template<class C>*/ inline std::string UpdateTraitsMapping(std::string TypeName, MDTraitsPtr Tr)
    {
//      MDTraitsPtr Tr = new C;
        MDTraitsPtr TrLookup = MDTraits::Find(Tr->Name());

        if(!TrLookup) MDTraits::Add(Tr->Name(), Tr);

        if(MDType::UpdateTraitsMapping(TypeName, Tr->Name()))
            return Tr->Name();
        else
            return "";
    }



    /*template<class C>*/ inline std::string AddTraitsMapping(const UL &Type, MDTraitsPtr Tr)
    {
//      MDTraitsPtr Tr = new C;
        MDTraitsPtr TrLookup = MDTraits::Find(Tr->Name());

        if(!TrLookup) MDTraits::Add(Tr->Name(), Tr);

        if(MDType::AddTraitsMapping(Type, Tr->Name()))
            return Tr->Name();
        else
            return "";
    }



    /*template<class C>*/ inline std::string UpdateTraitsMapping(const UL &Type, MDTraitsPtr Tr)
    {
//      MDTraitsPtr Tr = new C;
        MDTraitsPtr TrLookup = MDTraits::Find(Tr->Name());

        if(!TrLookup) MDTraits::Add(Tr->Name(), Tr);

        if(MDType::UpdateTraitsMapping(Type, Tr->Name()))
            return Tr->Name();
        else
            return "";
    }
}


namespace mxflib
{
    typedef std::map<MapIndex, MDValuePtr> MDValueMap;
}


namespace mxflib
{
    class MDValue : public RefCount<MDValue>, public MDValueMap
    {
    private:
        MDTypePtr Type;
        DataChunk Data;
//      int Size;
//      UInt8 *Data;                // DRAGONS: This should be a DataChunk

    public:
//      MDValueList Children;

    public:
        MDValue(const std::string &BaseType);
        MDValue(MDTypePtr BaseType);
        void Init(void);
        ~MDValue() {};

        void AddChild(MDValuePtr Child, int Index = -1);
        void Resize(UInt32 Index);

        MDValuePtr operator[](int Index);
        MDValuePtr Child(int Index) { return operator[](Index); };

        MDValuePtr operator[](const std::string ChildName);
        MDValuePtr Child(const std::string ChildName) { return operator[](ChildName); };

        MDValuePtr operator[](const UL &Child);
        MDValuePtr Child(const UL &Child) { return operator[](Child); };

        bool operator==(MDValuePtr &RHS) { return operator==(*RHS); }

        bool operator==(MDValue &RHS)
        {
            if(Type->EffectiveType() != RHS.Type->EffectiveType()) return false;
            if(Data.Size != RHS.Data.Size) return false;
            return (memcmp(Data.Data, RHS.Data.Data, Data.Size) == 0);
        }

        MDValue &operator=(MDValue &RHS)
        {
            // Do a bit-copy it the types are the same
            if(Type->EffectiveType() == RHS.Type->EffectiveType())
            {
                Data.Set(RHS.Data);
            }
            // ... otherwise copy by string value!
            else
            {
                SetString(RHS.GetString());
            }

            return *this;
        }

//      std::string ChildName(int Child);

        void SetInt(Int32 Val) { Type->Traits->SetInt(this, Val); };
        void SetInt64(Int64 Val) { Type->Traits->SetInt64(this, Val); };
        void SetUInt(UInt32 Val) { Type->Traits->SetUInt(this, Val); };
        void SetUInt64(UInt64 Val) { Type->Traits->SetUInt64(this, Val); };
        void SetUint(UInt32 Val) { Type->Traits->SetUInt(this, Val); };
        void SetUint64(UInt64 Val) { Type->Traits->SetUInt64(this, Val); };
        void SetString(std::string Val) { Type->Traits->SetString(this, Val); };
        Int32 GetInt(void) { return Type->Traits->GetInt(this); };
        Int64 GetInt64(void) { return Type->Traits->GetInt64(this); };
        UInt32 GetUInt(void) { return Type->Traits->GetUInt(this); };
        UInt64 GetUInt64(void) { return Type->Traits->GetUInt64(this); };
        UInt32 GetUint(void) { return Type->Traits->GetUInt(this); };
        UInt64 GetUint64(void) { return Type->Traits->GetUInt64(this); };
        std::string GetString(void) { return Type->Traits->GetString(this); };

        // Child value access
        // DRAGONS: May need to add code to check inside "optimised" compounds
        Int32 GetInt(const char *ChildName, Int32 Default = 0) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetInt(); else return Default; };
        Int64 GetInt64(const char *ChildName, Int64 Default = 0) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetInt64(); else return Default; };
        UInt32 GetUInt(const char *ChildName, UInt32 Default = 0) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetUInt(); else return Default; };
        UInt64 GetUInt64(const char *ChildName, UInt64 Default = 0) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetUInt64(); else return Default; };
        UInt32 GetUint(const char *ChildName, UInt32 Default = 0) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetUInt(); else return Default; };
        UInt64 GetUint64(const char *ChildName, UInt64 Default = 0) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetUInt64(); else return Default; };
        std::string GetString(const char *ChildName, std::string Default = "") { MDValuePtr Ptr = operator[](ChildName); if (Ptr) return Ptr->GetString(); else return Default; };
        void SetInt(const char *ChildName, Int32 Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetInt(Val); };
        void SetInt64(const char *ChildName, Int64 Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetInt64(Val); };
        void SetUInt(const char *ChildName, UInt32 Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetUInt(Val); };
        void SetUInt64(const char *ChildName, UInt64 Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetUInt64(Val); };
        void SetUint(const char *ChildName, UInt32 Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetUInt(Val); };
        void SetUint64(const char *ChildName, UInt64 Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetUInt64(Val); };
        void SetString(const char *ChildName, std::string Val) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->SetString(Val); };
        
        // Child value access
        // DRAGONS: May need to add code to check inside "optimised" compounds
        Int32 GetInt(const UL &Child, Int32 Default = 0) { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetInt(); else return Default; };
        Int64 GetInt64(const UL &Child, Int64 Default = 0) { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetInt64(); else return Default; };
        UInt32 GetUInt(const UL &Child, UInt32 Default = 0) { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetUInt(); else return Default; };
        UInt64 GetUInt64(const UL &Child, UInt64 Default = 0) { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetUInt64(); else return Default; };
        UInt32 GetUint(const UL &Child, UInt32 Default = 0) { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetUInt(); else return Default; };
        UInt64 GetUint64(const UL &Child, UInt64 Default = 0) { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetUInt64(); else return Default; };
        std::string GetString(const UL &Child, std::string Default = "") { MDValuePtr Ptr = operator[](Child); if (Ptr) return Ptr->GetString(); else return Default; };
        void SetInt(const UL &Child, Int32 Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetInt(Val); };
        void SetInt64(const UL &Child, Int64 Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetInt64(Val); };
        void SetUInt(const UL &Child, UInt32 Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetUInt(Val); };
        void SetUInt64(const UL &Child, UInt64 Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetUInt64(Val); };
        void SetUint(const UL &Child, UInt32 Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetUInt(Val); };
        void SetUint64(const UL &Child, UInt64 Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetUInt64(Val); };
        void SetString(const UL &Child, std::string Val) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->SetString(Val); };

        void ReadValue(const char *ChildName, const DataChunk &Source) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->ReadValue(Source); };
        void ReadValue(const char *ChildName, DataChunkPtr &Source) { MDValuePtr Ptr = operator[](ChildName); if (Ptr) Ptr->ReadValue(Source); };

        void ReadValue(const UL &Child, const DataChunk &Source) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->ReadValue(Source); };
        void ReadValue(const UL &Child, DataChunkPtr &Source) { MDValuePtr Ptr = operator[](Child); if (Ptr) Ptr->ReadValue(Source); };

        // DRAGONS: These should probably be private and give access via MDTraits
        // to prevent users tinkering!
        size_t MakeSize(size_t NewSize);

        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, int Count=0);

        const DataChunk& GetData(void) { return (const DataChunk&) Data; };

        DataChunkPtr PutData(void);

        // DRAGONS: This is dangerous!!
        void SetData(size_t MemSize, const UInt8 *Buffer) 
        { 
            Data.Resize(MemSize); 
            Data.Set(MemSize, Buffer); 
        };

        // Report the name of this item (the name of its type)
        const std::string &Name(void) const { ASSERT(Type); return Type->TypeName; };

        // Type access function
        MDTypePtr GetType(void) { return Type; };
        MDTypePtr EffectiveType(void) { return Type->EffectiveType(); };
        MDTypePtr EffectiveBase(void) { return Type->EffectiveBase(); };
    };
}


// These simple inlines need to be defined after MDValue
namespace mxflib
{
    inline MDValuePtr MDValuePtr::operator[](int Index) 
    { 
        // TODO: We need to find a solution to this!
        ASSERT(!(operator->()->GetType()->HandlesSubdata()));
        return operator->()->operator[](Index); 
    };
    inline MDValuePtr MDValuePtr::operator[](const std::string ChildName) 
    { 
        // TODO: We need to find a solution to this!
        ASSERT(!(operator->()->GetType()->HandlesSubdata()));
        return operator->()->operator[](ChildName); 
    };
}


#endif // MXFLIB__MDTYPE_H

---