deftypes.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2005, 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__DICTIONARY_H
#define MXFLIB__DICTIONARY_H

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


namespace mxflib
{
    // DRAGONS: Why are there two different (but similar) in memory versions of type records?
    //          The answer is that as some types depend on others the loading process requires stacking
    //          part-processed entries for later completion. It is not easy to stack the simple struct
    //          version, partly because of the char pointers to strings and partly because of the fact
    //          that the compound sub-items are linked by their position in the array rather than a pointer
    //          giving ownership - however these same features are required in order to allow data to be
    //          built at compile-time which is highly desirable. When a type definition table made from
    //          the "constant" struct version is loaded it is first copied to a list of classes for easy
    //          manipulation during further processing.

    enum TypeClass
    {
        TypeNULL = 0,                       
        TypeBasic,                          
        TypeInterpretation,                 
        TypeMultiple,                       
        TypeCompound,                       
        TypeSub,                            
        TypeEnum,                           
        TypeLabel,                          
        TypeSymbolSpace                     
    };

    enum TypeRef
    {
        TypeRefUndefined = -1,              
        TypeRefNone = 0,                    
        TypeRefStrong,                      
        TypeRefWeak,                        
        TypeRefTarget,                      
        TypeRefGlobal                       
    };

    struct ConstTypeRecord
    {
        TypeClass Class;                    
        const char *Type;                   
        const char *Detail;                 
        const char *Base;                   
        const char *UL;                     
        const char *Value;                  
        int Size;                           
        bool Endian;                        
        bool IsBatch;                       
        TypeRef RefType;                    
        const char *RefTarget;              
        const char *SymSpace;               
    };

    // Forward declare TypeRecord to allow TypeRecordPtr to be defined early
    class TypeRecord;

    typedef SmartPtr<TypeRecord> TypeRecordPtr;

    typedef std::list<TypeRecordPtr> TypeRecordList;

    typedef std::list<TypeRecordList> TypeRecordListList;

    class TypeRecord : public RefCount<TypeRecord>
    {
    public:
        TypeClass Class;                    
        std::string Type;                   
        std::string Detail;                 
        std::string Base;                   
        ULPtr UL;                           
        std::string Value;                  
        int Size;                           
        bool Endian;                        
        bool IsBatch;                       
        TypeRef RefType;                    
        std::string RefTarget;              
        SymbolSpacePtr SymSpace;            
        TypeRecordList Children;            

    public:
        TypeRecord()
        {
            Class = TypeNULL;
            Size = 0;
            Endian = false;
            IsBatch = false;
            RefType = TypeRefUndefined;
        }
    };


    int LoadTypes(char *TypesFile, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols);


    int LoadTypes(const ConstTypeRecord *TypesData, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols);


    int LoadTypes(TypeRecordList &TypesData, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols);


    inline MDTraitsPtr LookupTraits(const char* Name) { return MDTraits::Find(std::string(Name)); }


    bool DisableBuiltInTraits(void);


    /* Define macros for static type definitions */

#define MXFLIB_TYPE_START(Name) const ConstTypeRecord Name[] = {

#define MXFLIB_TYPE_START_SYM(Name, Sym) const ConstTypeRecord Name[] = { { TypeSymbolSpace, "", "", "", "", "", 0, false, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_BASIC(Name, Detail, UL, Size, Endian) { TypeBasic, Name, Detail, "", UL, "", Size, Endian, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_TYPE_BASIC_SYM(Name, Detail, UL, Size, Endian, Sym) { TypeBasic, Name, Detail, "", UL, "", Size, Endian, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_BASIC_REF(Name, Detail, UL, Size, Endian, RefType, RefTarget) { TypeBasic, Name, Detail, "", UL, "", Size, Endian, false, RefType, RefTarget, NULL },


#define MXFLIB_TYPE_BASIC_REF_SYM(Name, Detail, UL, Size, Endian, RefType, RefTarget, Sym) { TypeBasic, Name, Detail, "", UL, "", Size, Endian, false, RefType, RefTarget, Sym },


#define MXFLIB_TYPE_INTERPRETATION(Name, Detail, Base, UL, Size) { TypeInterpretation, Name, Detail, Base, UL, "", Size, false, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_TYPE_INTERPRETATION_SYM(Name, Detail, Base, UL, Size, Sym) { TypeInterpretation, Name, Detail, Base, UL, "", Size, false, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_INTERPRETATION_REF(Name, Detail, Base, UL, Size, RefType, RefTarget) { TypeInterpretation, Name, Detail, Base, UL, "", Size, false, false, RefType, RefTarget, NULL },


#define MXFLIB_TYPE_INTERPRETATION_REF_SYM(Name, Detail, Base, UL, Size, RefType, RefTarget, Sym) { TypeInterpretation, Name, Detail, Base, UL, "", Size, false, false, RefType, RefTarget, Sym },


#define MXFLIB_TYPE_MULTIPLE(Name, Detail, Base, UL, IsBatch, Size) { TypeMultiple, Name, Detail, Base, UL, "", Size, false, IsBatch, TypeRefUndefined, NULL, NULL },


#define MXFLIB_TYPE_MULTIPLE_SYM(Name, Detail, Base, UL, IsBatch, Size, Sym) { TypeMultiple, Name, Detail, Base, UL, "", Size, false, IsBatch, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_MULTIPLE_REF(Name, Detail, Base, UL, IsBatch, Size, RefType, RefTarget) { TypeMultiple, Name, Detail, Base, UL, "", Size, false, IsBatch, RefType, RefTarget, NULL },


#define MXFLIB_TYPE_MULTIPLE_REF_SYM(Name, Detail, Base, UL, IsBatch, Size, RefType, RefTarget, Sym) { TypeMultiple, Name, Detail, Base, UL, "", Size, false, IsBatch, RefType, RefTarget, Sym },


#define MXFLIB_TYPE_COMPOUND(Name, Detail, UL) { TypeCompound, Name, Detail, "", UL, "", 0, false, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_TYPE_COMPOUND_SYM(Name, Detail, UL, Sym) { TypeCompound, Name, Detail, "", UL, "", 0, false, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_COMPOUND_ITEM(Name, Detail, Type, UL, Size) { TypeSub, Name, Detail, Type, UL, "", Size, false, false, TypeRefUndefined, NULL, NULL },

#define MXFLIB_TYPE_COMPOUND_END


#define MXFLIB_TYPE_ENUM(Name, Detail, Type, UL) { TypeEnum, Name, Detail, Type, UL, "", 0, false, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_TYPE_ENUM_SYM(Name, Detail, Type, UL, Sym) { TypeEnum, Name, Detail, Type, UL, "", 0, false, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_ENUM_VALUE(Name, Detail, Value) { TypeSub, Name, Detail, "", "", Value, 0, false, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_LABEL(Name, Detail, UL) { TypeLabel, Name, Detail, "", UL, NULL, 0, false, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_LABEL_SYM(Name, Detail, UL, Sym) { TypeLabel, Name, Detail, "", UL, NULL, 0, false, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_MASKED_LABEL(Name, Detail, UL, Mask) { TypeLabel, Name, Detail, "", UL, Mask, 0, false, false, TypeRefUndefined, NULL, NULL },


#define MXFLIB_MASKED_LABEL_SYM(Name, Detail, UL, Mask, Sym) { TypeLabel, Name, Detail, "", UL, Mask, 0, false, false, TypeRefUndefined, NULL, Sym },


#define MXFLIB_TYPE_ENUM_END

#define MXFLIB_TYPE_END { TypeNULL, "", "", "", "", "", 0, false, false, TypeRefUndefined, NULL, NULL } };

/* Example usage:
    MXFLIB_TYPE_START(TypeArray)
        MXFLIB_TYPE_BASIC("UInt8", "Unsigned 8 bit integer", "urn:x-ul:060E2B34.0104.0101.01010100.00000000", 1, false)
        MXFLIB_TYPE_BASIC("UInt16", "Unsigned 16 bit integer", "urn:x-ul:060E2B34.0104.0101.01010200.00000000", 2, true)
        MXFLIB_TYPE_BASIC("Int32", "32 bit integer", "urn:x-ul:060E2B34.0104.0101.01010700.00000000", 4, true)
        
        MXFLIB_TYPE_INTERPRETATION("VersionType", "Version number (created from major*256 + minor)", "UInt16", "urn:x-ul:060E2B34.0104.0101.03010300.00000000", 0)
        MXFLIB_TYPE_INTERPRETATION("UTF16", "Unicode UTF-16 coded character", "UInt16", "urn:x-ul:060E2B34.0104.0101.01100100.00000000", 0)
        MXFLIB_TYPE_INTERPRETATION("Boolean", "Boolean", "UInt8", "urn:x-ul:060E2B34.0104.0101.01040100.00000000", 0)

        MXFLIB_TYPE_MULTIPLE("UTF16String", "Unicode UTF-16 coded string", "UTF16", "urn:x-ul:060E2B34.0104.0101.01100200.00000000", false, 0)
        MXFLIB_TYPE_MULTIPLE("Int32Array", "Array of Int32 values", "Int32", "urn:x-ul:060E2B34.0104.0101.04010900.00000000", false, 0)
        MXFLIB_TYPE_MULTIPLE("Int32Batch", "Batch of Int32 values", "Int32", "urn:x-ul:060E2B34.0104.0101.04030200.00000000", true, 0)
        MXFLIB_TYPE_MULTIPLE("Int32Pair", "Pair of Int32 values", "Int32", "", false, 2)

        MXFLIB_TYPE_COMPOUND("Rational", "Rational", "urn:x-ul:060E2B34.0104.0101.03010100.00000000")
            MXFLIB_TYPE_COMPOUND_ITEM("Numerator", "Numerator", "Int32", "urn:x-ul:060E2B34.0104.0101.03010101.00000000", 0)
            MXFLIB_TYPE_COMPOUND_ITEM("Denominator", "Denominator", "Int32", "urn:x-ul:060E2B34.0104.0101.03010102.00000000", 0)
        MXFLIB_TYPE_COMPOUND_END
    MXFLIB_TYPE_END
*/
}


namespace mxflib
{
    enum ClassType
    {
        ClassNULL = 0,                      
        ClassPack,                          
        ClassSet,                           
        ClassVector,                        
        ClassArray,                         
        ClassItem,                          
        ClassRename,                        
        ClassSymbolSpace                    
    };

    enum ClassUsage
    {
        ClassUsageNULL = 0,                 
        ClassUsageOptional,                 
        ClassUsageDecoderRequired,          
        ClassUsageEncoderRequired,          
        ClassUsageRequired,                 
        ClassUsageBestEffort,               
        ClassUsageToxic,                    
        ClassUsageDark                      
    };

    typedef TypeRef ClassRef;

    const ClassRef ClassRefUndefined = TypeRefUndefined;

    const ClassRef ClassRefNone = TypeRefNone;

    const ClassRef ClassRefStrong = TypeRefStrong;

    const ClassRef ClassRefWeak = TypeRefWeak;

    const ClassRef ClassRefGlobal = TypeRefGlobal;

    const ClassRef ClassRefTarget = TypeRefTarget;


    struct ConstClassRecord
    {
        ClassType Class;                    
        unsigned int MinSize;               
        unsigned int MaxSize;               
        const char *Name;                   
        const char *Detail;                 
        ClassUsage Usage;                   
        const char *Base;                   
        UInt16 Tag;                         
        const char *UL;                     
        const char *Default;                
        const char *DValue;                 
        ClassRef RefType;                   
        const char *RefTarget;              
        const char *SymSpace;               
        bool ExtendSubs;                    
    };

    // Forward declare ClassRecord to allow ClassRecordPtr to be defined early
    class ClassRecord;

    typedef SmartPtr<ClassRecord> ClassRecordPtr;

    typedef std::list<ClassRecordPtr> ClassRecordList;

    typedef std::list<ClassRecordList> ClassRecordListList;

    class ClassRecord : public RefCount<ClassRecord>
    {
    public:
        ClassType Class;                    
        unsigned int MinSize;               
        unsigned int MaxSize;               
        std::string Name;                   
        std::string Detail;                 
        ClassUsage Usage;                   
        std::string Base;                   
        UInt16 Tag;                         
        ULPtr UL;                           
        bool HasDefault;                    
        std::string Default;                
        bool HasDValue;                     
        std::string DValue;                 
        ClassRecordList Children;           
        ClassRef RefType;                   
        std::string RefTarget;              
        SymbolSpacePtr SymSpace;            
        bool ExtendSubs;                    
    
    public:
        ClassRecord()
        {
            Class = ClassNULL;
            MinSize = 0;
            MaxSize = 0;
            Usage = ClassUsageNULL;
            Tag = 0;
            HasDefault = false;
            HasDValue = false;
            RefType = ClassRefUndefined;
            ExtendSubs = true;
        }
    };



    int LoadClasses(ClassRecordList &ClassesData, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols);


    int LoadClasses(const ConstClassRecord *ClassData, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols);


    /* Define macros for static type definitions */

#define MXFLIB_CLASS_START(Name) const ConstClassRecord Name[] = {

#define MXFLIB_CLASS_START_SYM(Name, Sym) const ConstClassRecord Name[] = { { ClassSymbolSpace, 0, 0, "", "", ClassUsageNULL, "", 0, "", NULL, NULL, ClassRefUndefined, "", Sym, true },


#define MXFLIB_CLASS_SET(Name, Detail, Base, UL) { ClassSet, 2, 2, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_SET_SYM(Name, Detail, Base, UL, Sym) { ClassSet, 2, 2, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", Sym, true },


#define MXFLIB_CLASS_SET_NOSUB(Name, Detail, Base, UL) { ClassSet, 2, 2, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", NULL, false },


#define MXFLIB_CLASS_SET_NOSUB_SYM(Name, Detail, Base, UL, Sym) { ClassSet, 2, 2, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", Sym, false },

#define MXFLIB_CLASS_SET_END { ClassNULL, 0, 0, "", "", ClassUsageNULL, "", 0, "", NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_FIXEDPACK(Name, Detail, Base, UL) { ClassPack, 0, 0, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_FIXEDPACK_SYM(Name, Detail, Base, UL, Sym) { ClassPack, 0, 0, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", Sym, true },


#define MXFLIB_CLASS_FIXEDPACK_NOSUB(Name, Detail, Base, UL) { ClassPack, 0, 0, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", NULL, false },


#define MXFLIB_CLASS_FIXEDPACK_NOSUB_SYM(Name, Detail, Base, UL, Sym) { ClassPack, 0, 0, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", Sym, false },

#define MXFLIB_CLASS_FIXEDPACK_END { ClassNULL, 0, 0, "", "", ClassUsageNULL, "", 0, "", NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_ITEM(Name, Detail, Usage, Type, MinSize, MaxSize, Tag, UL, Default, DValue) { ClassItem, MinSize, MaxSize, Name, Detail, Usage, Type, Tag, UL, Default, DValue, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_ITEM_REF(Name, Detail, Usage, Type, MinSize, MaxSize, Tag, UL, RefType, RefTarget, Default, DValue) { ClassItem, MinSize, MaxSize, Name, Detail, Usage, Type, Tag, UL, Default, DValue, RefType, RefTarget, NULL, true },


#define MXFLIB_CLASS_ITEM_SYM(Name, Detail, Usage, Type, MinSize, MaxSize, Tag, UL, Default, DValue, Sym) { ClassItem, MinSize, MaxSize, Name, Detail, Usage, Type, Tag, UL, Default, DValue, ClassRefUndefined, "", Sym, true },


#define MXFLIB_CLASS_ITEM_REF_SYM(Name, Detail, Usage, Type, MinSize, MaxSize, Tag, UL, RefType, RefTarget, Default, DValue, Sym) { ClassItem, MinSize, MaxSize, Name, Detail, Usage, Type, Tag, UL, Default, DValue, RefType, RefTarget, Sym, true },


#define MXFLIB_CLASS_VECTOR(Name, Detail, Usage, Tag, UL) { ClassVector, 0, 0, Name, Detail, Usage, "", Tag, UL, NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_VECTOR_REF(Name, Detail, Usage, Tag, UL, RefType, RefTarget) { ClassVector, 0, 0, Name, Detail, Usage, "", Tag, UL, NULL, NULL, RefType, RefTarget, NULL, true },

#define MXFLIB_CLASS_VECTOR_END { ClassNULL, 0, 0, "", "", ClassUsageNULL, "", 0, "", NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_ARRAY(Name, Detail, Usage, Tag, UL) { ClassArray, 0, 0, Name, Detail, Usage, "", Tag, UL, NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_ARRAY_REF(Name, Detail, Usage, Tag, UL, RefType, RefTarget) { ClassArray, 0, 0, Name, Detail, Usage, "", Tag, UL, NULL, NULL, RefType, RefTarget, NULL, true },

#define MXFLIB_CLASS_ARRAY_END { ClassNULL, 0, 0, "", "", ClassUsageNULL, "", 0, "", NULL, NULL, ClassRefUndefined, "", NULL, true },


#define MXFLIB_CLASS_RENAME(Name, Detail, Base, UL) { ClassRename, 0, 0, Name, Detail, ClassUsageNULL, Base, 0, UL, NULL, NULL, ClassRefUndefined, "", NULL, true },

#define MXFLIB_CLASS_END { ClassNULL, 0, 0, "", "", ClassUsageNULL, "", 0, "", NULL, NULL, ClassRefUndefined, "", NULL, true } };


/* Example usage:
    MXFLIB_CLASS_RENAME("KLVFill", "KLV Filler packet", "RAW", "06 0E 2B 34 01 01 01 01 03 01 02 10 01 00 00 00")
    MXFLIB_CLASS_FIXEDPACK("PartitionMetadata", "Identifies a Partition Pack", "")
        MXFLIB_CLASS_ITEM("MajorVersion", "Major Version number of MXF byte-level format (non-backwards compatible version number)", ClassUsageRequired, "UInt16", 2, 2, "06 0e 2b 34 01 01 01 04  03 01 02 01 06 00 00 00", "", "0001", "")
        MXFLIB_CLASS_ITEM("MinorVersion", "Minor Version number of MXF byte-level format (backwards compatible version number)", ClassUsageRequired, "UInt16", 2, 2, "06 0e 2b 34 01 01 01 04  03 01 02 01 06 00 00 00", "", "0001", "")
...
        MXFLIB_CLASS_ITEM_REF("PrimaryPackage", "The primary Package in this file", ClassUsageOptional, "UUID", 16, 16, "06 0e 2b 34 01 01 01 04  06 01 01 04 01 08 00 00", "3b 08", "", "", RefWeak, "GenericPackage")
...
        MXFLIB_CLASS_VECTOR("EssenceContainers", "The unordered batch of Universal Labels of Essence Containers used in or referenced by this file", ClassUsageRequired, "06 0e 2b 34 01 01 01 05  01 02 02 10 02 01 00 00", "", "")
            MXFLIB_CLASS_ITEM("EssenceContainer", "Universal Labels of Essence Container", ClassUsageRequired, "Label", 16, 16, "", "", "", "")
        MXFLIB_CLASS_VECTOR_END
    MXFLIB_CLASS_END

    MXFLIB_CLASS_RENAME("OpenHeader", "Open Header Partition Pack", "PartitionMetadata", "06 0e 2b 34 02 05 01 01  0d 01 02 01 01 02 01 00")
    MXFLIB_CLASS_RENAME("OpenCompleteHeader", "Open Complete Header Partition Pack", "PartitionMetadata", "06 0e 2b 34 02 05 01 01  0d 01 02 01 01 02 03 00")

 <PrimaryPackage detail="The primary Package in this file" use="optional" type="UUID" minLength="16" maxLength="16" key="3b 08" globalKey="06 0e 2b 34 01 01 01 04  06 01 01 04 01 08 00 00" ref="weak" target="GenericPackage"/>
*/
}


namespace mxflib
{
    enum DictionaryType
    {
        DictionaryNULL = 0,                 
        DictionaryTypes,                    
        DictionaryClasses                   
    };

    struct ConstDictionaryRecord
    {
        DictionaryType Type;                
        const void *Dict;                   
    };

    // Forward declare Dictionary to allow DictionaryPtr to be defined early
    class Dictionary;

    typedef SmartPtr<Dictionary> DictionaryPtr;

    typedef std::list<DictionaryPtr> DictionaryList;

    class Dictionary : public RefCount<Dictionary>
    {
    public:
        TypeRecordListList Types;           
        ClassRecordListList Classes;        
    };



    int LoadDictionary(DictionaryPtr &DictionaryData, SymbolSpacePtr DefaultSymbolSpace, bool FastFail = false);


    inline int LoadDictionary(DictionaryPtr &DictionaryData, bool FastFail = false, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols)
    {
        return LoadDictionary(DictionaryData, DefaultSymbolSpace, FastFail );
    }


    int LoadDictionary(const ConstDictionaryRecord *DictionaryData, SymbolSpacePtr DefaultSymbolSpace, bool FastFail = false);


    inline int LoadDictionary(const ConstDictionaryRecord *DictionaryData, bool FastFail = false, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols)
    {
        return LoadDictionary(DictionaryData, DefaultSymbolSpace, FastFail);
    }


    int LoadDictionary(const char *DictFile, SymbolSpacePtr DefaultSymbolSpace, bool FastFail = false);


    inline int LoadDictionary(std::string DictFile, SymbolSpacePtr DefaultSymbolSpace, bool FastFail = false)
    {
        return LoadDictionary(DictFile.c_str(), DefaultSymbolSpace, FastFail );
    }


    inline int LoadDictionary(const char *DictFile, bool FastFail = false, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols)
    {
        return LoadDictionary(DictFile, DefaultSymbolSpace, FastFail );
    }


    inline int LoadDictionary(std::string DictFile, bool FastFail = false, SymbolSpacePtr DefaultSymbolSpace = MXFLibSymbols)
    {
        return LoadDictionary(DictFile.c_str(), DefaultSymbolSpace, FastFail );
    }


#define MXFLIB_DICTIONARY_START(Name)       const ConstDictionaryRecord Name[] = {

#define MXFLIB_DICTIONARY_TYPES(Types)      { DictionaryTypes, Types },

#define MXFLIB_DICTIONARY_CLASSES(Classes)  { DictionaryClasses, Classes },

#define MXFLIB_DICTIONARY_END               { DictionaryNULL, NULL } };

/* Example usage:
    MXFLIB_DICTIONARY_START(Dict)
        MXFLIB_DICTIONARY_TYPES(MyTypes)
        MXFLIB_DICTIONARY_CLASSES(MyClasses)
    MXFLIB_DICTIONARY_END
*/
}

namespace mxflib
{
    class Label;

    // A Smart pointer to a Label
    typedef SmartPtr<Label> LabelPtr;

    class Label : public RefCount<Label>
    {
    protected:
        UL Value;                                       
        UInt8 Mask[16];                                 
        bool NonZeroMask;                               
        std::string Name;                               
        std::string Detail;                             

    protected:
        typedef std::map<UL, LabelPtr> LabelULMap;

        typedef std::multimap<UL, LabelPtr> LabelULMultiMap;

        static LabelULMap LabelMap;

        static LabelULMultiMap LabelMultiMap;

    protected:
        // Private constructor - to build a new label one of the Insert() functions must be called
        Label(std::string LabelName, std::string Detail, const UInt8 *LabelUL, const UInt8 *LabelMask) 
            : Value(LabelUL), Detail(Detail)
        {
            Init(LabelName, LabelMask);
        }

        // Private constructor - to build a new label one of the Insert() functions must be called
        Label(std::string LabelName, std::string Detail, const UUID &LabelULasUUID, const UInt8 *LabelMask) 
            : Value(LabelULasUUID), Detail(Detail)
        {
            Init(LabelName, LabelMask);
        }

        // Constructor common part - called by constructors
        void Init(std::string LabelName, const UInt8 *LabelMask)
        {
            Name = LabelName;

            if(LabelMask)
            {
                memcpy(Mask, LabelMask, 16);
                NonZeroMask = true;
            }
            else
            {
                memset(Mask, 0, 16);
                NonZeroMask = false;
            }
        }

    public:
        std::string GetName(void) { return Name; };

        std::string GetDetail(void) { return Detail; };

        bool HasMask(void) { return NonZeroMask; }

    public:

        static bool Insert(std::string Name, std::string Detail, const UInt8 *LabelValue, const UInt8 *LabelMask = NULL);


        static bool Insert(std::string Name, std::string Detail, const ULPtr &LabelValue, const UInt8 *LabelMask = NULL);


        static bool Insert(std::string Name, std::string Detail, const UL &LabelValue, const UInt8 *LabelMask = NULL);


        static bool Insert(std::string Name, std::string Detail, const UUIDPtr &LabelValue, const UInt8 *LabelMask = NULL);


        static bool Insert(std::string Name, std::string Detail, const mxflib::UUID &LabelValue, const UInt8 *LabelMask = NULL);

    public:
        static LabelPtr Find(const UL &LabelValue);

        static LabelPtr Find(const ULPtr &LabelValue)
        {
            return Find(*LabelValue);
        }

        static LabelPtr Find(const UInt8 *LabelValue)
        {
            /* Make a value UL and use that in the main search */
            UL ValueUL(LabelValue);
            return Find(ValueUL);
        }
    };
}

#endif // MXFLIB__DICTIONARY_H

---