metadata.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003, Matt Beard
 *  Portions Copyright (c) 2003, Metaglue Corporation
 *
 *  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__METADATA_H
#define MXFLIB__METADATA_H

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

    class MetadataPtr : public SmartPtr<Metadata>
    {
    public:
        MetadataPtr() : SmartPtr<Metadata>() {}
        MetadataPtr(IRefCount<Metadata> * ptr) : SmartPtr<Metadata>(ptr) {};
        
        MDObjectPtr operator[](const char *ChildName);
        MDObjectPtr operator[](MDOTypePtr ChildType);
        MDObjectPtr operator[](const UL &ChildType);
        MDObjectPtr operator[](ULPtr &ChildType);
    };
}


// Forward definitions
namespace mxflib
{
    class Package;
    class PackagePtr : public SmartPtr<Package>
    {
    public:
        PackagePtr() : SmartPtr<Package>() {}
        PackagePtr(IRefCount<Package> * ptr) : SmartPtr<Package>(ptr) {}
        
        MDObjectPtr operator[](const char *ChildName);
        MDObjectPtr operator[](MDOTypePtr ChildType);
        MDObjectPtr operator[](const UL &ChildType);
        MDObjectPtr operator[](ULPtr &ChildType);
    };

    class PackageParent : public ParentPtr<Package>
    {
    public:
        PackageParent() : ParentPtr<Package>() {}
        PackageParent(IRefCount<Package> * ptr) : ParentPtr<Package>(ptr) {}

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

    typedef std::list<PackagePtr> PackageList;


    class Track;
    class TrackPtr : public SmartPtr<Track>
    {
    public:
        TrackPtr() : SmartPtr<Track>() {}
        TrackPtr(IRefCount<Track> * ptr) : SmartPtr<Track>(ptr) {}

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

    typedef std::list<TrackPtr> TrackList;


    class TrackParent : public ParentPtr<Track>
    {
    public:
        TrackParent() : ParentPtr<Track>() {}
        TrackParent(IRefCount<Track> * ptr) : ParentPtr<Track>(ptr) {}

        TrackParent & operator=(const TrackPtr &sp) { __Assign(sp.GetRef()); return *this;}

        TrackParent & operator=(IRefCount<Track> *ptr) { __Assign(ptr); return *this;}

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



    class Component : public ObjectInterface, public RefCount<Component>
    {
    protected:
        TrackParent Parent;                 

        Component(MDObjectPtr BaseObject) : ObjectInterface(BaseObject) {}

    public:
        Component(std::string BaseType) { Object = new MDObject(BaseType); if(Object) Object->SetOuter(this); }
        Component(MDOTypePtr BaseType) { Object = new MDObject(BaseType); if(Object) Object->SetOuter(this); }
        Component(const UL &BaseUL) { Object = new MDObject(BaseUL); if(Object) Object->SetOuter(this); }
        Component(ULPtr &BaseUL) { Object = new MDObject(BaseUL); if(Object) Object->SetOuter(this); }

        TrackParent GetParent(void) { return Parent; };

        void SetParent(TrackPtr &NewParent) { Parent = NewParent; }

        void SetParent(IRefCount<Track> *NewParent) { Parent = TrackParent(NewParent); }


        virtual bool MakeLink(TrackPtr SourceTrack, Int64 StartPosition = 0) { return false; }


        virtual bool MakeLink(UMIDPtr LinkUMID, UInt32 LinkTrackID, Int64 StartPosition = 0) { return false; }


        virtual void SetDuration(Length Duration = -1);

        virtual ~Component() {};
    };

    typedef SmartPtr<Component> ComponentPtr;

    typedef std::list<ComponentPtr> ComponentList;


    class SourceClip;
    class SourceClipPtr : public SmartPtr<SourceClip>
    {
    public:
        SourceClipPtr() : SmartPtr<SourceClip>() {}


        SourceClipPtr(IRefCount<Component> * ptr) : SmartPtr<SourceClip>((IRefCount<SourceClip> *)ptr) {}

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

    class DMSourceClip;
    class DMSourceClipPtr : public SmartPtr<DMSourceClip>
    {
    public:
        DMSourceClipPtr() : SmartPtr<DMSourceClip>() {}


        DMSourceClipPtr(IRefCount<Component> * ptr) : SmartPtr<DMSourceClip>((IRefCount<DMSourceClip> *)ptr) {}

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

    class TimecodeComponent;
    class TimecodeComponentPtr : public SmartPtr<TimecodeComponent>
    {
    public:
        TimecodeComponentPtr() : SmartPtr<TimecodeComponent>() {}


        TimecodeComponentPtr(IRefCount<Component> * ptr) : SmartPtr<TimecodeComponent>((IRefCount<TimecodeComponent> *)ptr) {}

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

    class DMSegment;
    class DMSegmentPtr : public SmartPtr<DMSegment>
    {
    public:
        DMSegmentPtr() : SmartPtr<DMSegment>() {}


        DMSegmentPtr(IRefCount<Component> * ptr) : SmartPtr<DMSegment>((IRefCount<DMSegment> *)ptr) {};

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



namespace mxflib
{
    class SourceClip : public Component
    {
    protected:
        SourceClip(MDObjectPtr BaseObject) : Component(BaseObject) {}

    public:
        SourceClip(std::string BaseType) : Component(BaseType) {};
        SourceClip(MDOTypePtr BaseType) : Component(BaseType) {};
        SourceClip(const UL &BaseUL) : Component(BaseUL) {};
        SourceClip(ULPtr &BaseUL) : Component(BaseUL) {};

        virtual bool MakeLink(TrackPtr SourceTrack, Int64 StartPosition = 0);

        virtual bool MakeLink(UMIDPtr LinkUMID, UInt32 LinkTrackID, Int64 StartPosition = 0);


        static SourceClipPtr GetSourceClip(MDObjectPtr Object);

        static SourceClipPtr Parse(MDObjectPtr BaseObject);
    };
}


namespace mxflib
{
    class DMSourceClip : public SourceClip
    {
    protected:
        DMSourceClip(MDObjectPtr BaseObject) : SourceClip(BaseObject) {}

    public:
        DMSourceClip(std::string BaseType) : SourceClip(BaseType) {};
        DMSourceClip(MDOTypePtr BaseType) : SourceClip(BaseType) {};
        DMSourceClip(const UL &BaseUL) : SourceClip(BaseUL) {};
        DMSourceClip(ULPtr &BaseUL) : SourceClip(BaseUL) {};


        static DMSourceClipPtr GetDMSourceClip(MDObjectPtr Object);

        static DMSourceClipPtr Parse(MDObjectPtr BaseObject);
    };
}


namespace mxflib
{
    class TimecodeComponent : public Component
    {
    protected:
        TimecodeComponent(MDObjectPtr BaseObject) : Component(BaseObject) {}

    public:
        TimecodeComponent(std::string BaseType) : Component(BaseType) {};
        TimecodeComponent(MDOTypePtr BaseType) : Component(BaseType) {};
        TimecodeComponent(const UL &BaseUL) : Component(BaseUL) {};
        TimecodeComponent(ULPtr &BaseUL) : Component(BaseUL) {};


        static TimecodeComponentPtr GetTimecodeComponent(MDObjectPtr Object);

        static TimecodeComponentPtr Parse(MDObjectPtr BaseObject);
    };
}

namespace mxflib
{
    class DMSegment : public Component
    {
    protected:
        DMSegment(MDObjectPtr BaseObject) : Component(BaseObject) {}

    public:
        DMSegment(std::string BaseType) : Component(BaseType) {};
        DMSegment(MDOTypePtr BaseType) : Component(BaseType) {};
        DMSegment(const UL &BaseUL) : Component(BaseUL) {};
        DMSegment(ULPtr &BaseUL) : Component(BaseUL) {};

//      //! Make a link to a specified track (in the same Package)
//      bool MakeLink(TrackPtr SourceTrack);

        bool MakeLink(MDObjectPtr DMFramework);


        static DMSegmentPtr GetDMSegment(MDObjectPtr Object);

        static DMSegmentPtr Parse(MDObjectPtr BaseObject);
    };
}

namespace mxflib
{
    class Track : public ObjectInterface, public RefCount<Track>
    {
    public:
        enum TrackType
        {
            TypeUndetermined = -1,              
            TypeUnknown = 0,                    
            TypeTimecode,                       
            TypeDM,                             
            TypePicture,                        
            TypeSound,                          
            TypeData,                           
            TypeAux,                            
            TypePText                           
        };

    public:
        ComponentList Components;               

    protected:
        PackageParent Parent;                   

        TrackType ThisTrackType;                

        Track(MDObjectPtr BaseObject) : ObjectInterface(BaseObject) 
        {
            ThisTrackType = TypeUndetermined;
        }

        struct TrackTypeListItem
        {
            TrackType Type;                     
            UInt8 Label[16];                    
            int CompareLength;                  
        };

        typedef std::list<TrackTypeListItem> TrackTypeList;

        static TrackTypeList TrackTypes;        
        static bool TrackTypesInited;           

    public:
        Track(std::string BaseType) { Object = new MDObject(BaseType); ThisTrackType = TypeUndetermined; }
        Track(MDOTypePtr BaseType) { Object = new MDObject(BaseType); ThisTrackType = TypeUndetermined; }
        Track(const UL &BaseUL) { Object = new MDObject(BaseUL); ThisTrackType = TypeUndetermined; }
        Track(ULPtr &BaseUL) { Object = new MDObject(BaseUL); ThisTrackType = TypeUndetermined; }

        SourceClipPtr AddSourceClip(Int64 Duration = -1);

        TimecodeComponentPtr AddTimecodeComponent(Int64 Start = 0, Int64 Duration = -1)
        {
            MDObjectPtr EditRate = Child("EditRate");
            if(EditRate)
            {
                double FPS = ((double)GetInt("Numerator", 1)) / ((double)GetInt("Denominator", 1));
                return AddTimecodeComponent((UInt16)FPS, (GetInt("Denominator") == 1001), Start, Duration);
            }

            // Default to an edit rate of 1 if no known edit rate
            return AddTimecodeComponent(1, false, Start, Duration);
        }

        TimecodeComponentPtr AddTimecodeComponent(UInt16 FPS, bool DropFrame, Int64 Start = 0, Int64 Duration = -1);

        DMSegmentPtr AddDMSegment(Int64 EventStart = -1, Int64 Duration = -1);

        DMSourceClipPtr AddDMSourceClip(Int64 Duration = -1);

        Int64 UpdateDuration(void);

        PackageParent GetParent(void) { return Parent; };

        void SetParent(PackagePtr &NewParent) { Parent = PackageParent(NewParent.GetRef()); }

        void SetParent(IRefCount<Package> *NewParent) { Parent = PackageParent(NewParent); }

        TrackType GetType(void);

        bool IsEssenceTrack(void)
        {
            TrackType ThisType = GetType();

            switch(ThisType)
            {
                case TypePicture:               
                case TypeSound:                 
                case TypeData:                  

                // DRAGONS: We currently don't treat the following as essence
//              case TypeAux:                   //!< Auxiliary track
//              case TypePText:                 //!< Parsed Text track
                    return true;

                default:
                    return false;
            }
        }

        bool IsTimecodeTrack(void)
        {
            if(GetType() == TypeTimecode) return true;
            return false;
        }

        bool IsDMTrack(void)
        {
            if(GetType() == TypeDM) return true;
            return false;
        }


        static TrackPtr GetTrack(MDObjectPtr Object);

        static TrackPtr Parse(MDObjectPtr BaseObject);


        static void AddTrackType(TrackType Type, const UInt8 *Label, int CompareLength = 16);

    protected:
        static void InitTrackTypes(void);
    };
}


namespace mxflib
{
    enum
    {
        DurationUnspecified = -1,      
        DurationInstantaneous = 0,     
    };


    class Package : public ObjectInterface, public RefCount<Package>
    {
    public:
        TrackList Tracks;                       

    protected:
        UInt32 LastTrackID;                     

        Package(MDObjectPtr BaseObject) : ObjectInterface(BaseObject) {}

    private:
        // Can't create from nothing
        Package();

    public:
        Package(std::string BaseType) : LastTrackID(0) { Object = new MDObject(BaseType); if(Object) Object->SetOuter(this); }
        Package(MDOTypePtr BaseType) : LastTrackID(0) { Object = new MDObject(BaseType); if(Object) Object->SetOuter(this); }
        Package(const UL &BaseUL) : LastTrackID(0) { Object = new MDObject(BaseUL); if(Object) Object->SetOuter(this); }
        Package(ULPtr &BaseUL) : LastTrackID(0) { Object = new MDObject(BaseUL); if(Object) Object->SetOuter(this); }

        TrackPtr AddTrack(ULPtr DataDef, UInt32 TrackNumber, Rational EditRate, std::string TrackName = "", UInt32 TrackID = 0);

        TrackPtr AddTrack(ULPtr DataDef, UInt32 TrackNumber, Rational EditRate, Length DefaultDuration, std::string TrackName = "", UInt32 TrackID = 0);

        TrackPtr AddTrack(ULPtr DataDef, UInt32 TrackNumber, std::string TrackName = "", UInt32 TrackID = 0);

        TrackPtr AddPictureTrack(Rational EditRate, std::string TrackName = "Picture Track", UInt32 TrackID = 0) { return AddPictureTrack(0, EditRate, TrackName, TrackID); }
        TrackPtr AddPictureTrack(UInt32 TrackNumber, Rational EditRate, std::string TrackName = "Picture Track", UInt32 TrackID = 0)
        {
            static const ULPtr PictureDD = new UL(TrackTypeDataDefPicture);
            return AddTrack(PictureDD, TrackNumber, EditRate, TrackName, TrackID);
        }

        TrackPtr AddSoundTrack(Rational EditRate, std::string TrackName = "Sound Track", UInt32 TrackID = 0) { return AddSoundTrack(0, EditRate, TrackName, TrackID); }
        TrackPtr AddSoundTrack(UInt32 TrackNumber, Rational EditRate, std::string TrackName = "Sound Track", UInt32 TrackID = 0)
        {
            static const ULPtr SoundDD = new UL(TrackTypeDataDefSound);
            return AddTrack(SoundDD, TrackNumber, EditRate, TrackName, TrackID);
        }

        TrackPtr AddDataTrack(Rational EditRate, std::string TrackName = "Data Track", UInt32 TrackID = 0) { return AddDataTrack(0, EditRate, TrackName, TrackID); }
        TrackPtr AddDataTrack(UInt32 TrackNumber, Rational EditRate, std::string TrackName = "Data Track", UInt32 TrackID = 0)
        {
            static const ULPtr DataDD = new UL(TrackTypeDataDefData);
            return AddTrack(DataDD, TrackNumber, EditRate, TrackName, TrackID);
        }

        TrackPtr AddTimecodeTrack(Rational EditRate, std::string TrackName = "Timecode Track", UInt32 TrackID = 0) { return AddTimecodeTrack(0, EditRate, TrackName, TrackID); }
        TrackPtr AddTimecodeTrack(UInt32 TrackNumber, Rational EditRate, std::string TrackName = "Timecode Track", UInt32 TrackID = 0)
        {
            static const ULPtr TCDD = new UL(TrackTypeDataDefTimecode12M);
            return AddTrack(TCDD, TrackNumber, EditRate, TrackName, TrackID);
        }

        TrackPtr AddDMTrack(Rational EditRate, Length DefaultDuration, std::string TrackName = "Descriptive Track", UInt32 TrackID = 0) { return AddDMTrack(0, EditRate, DefaultDuration, TrackName, TrackID); }
        TrackPtr AddDMTrack(UInt32 TrackNumber, Rational EditRate, Length DefaultDuration, std::string TrackName = "Descriptive Track", UInt32 TrackID = 0)
        {
            static const ULPtr TCDM = new UL(TrackTypeDataDefDM);
            return AddTrack(TCDM, TrackNumber, EditRate, DefaultDuration, TrackName, TrackID);
        }

        TrackPtr AddDMTrack(Rational EditRate, std::string TrackName = "Descriptive Track", UInt32 TrackID = 0) { return AddDMTrack(0, EditRate, TrackName, TrackID); }
        TrackPtr AddDMTrack(UInt32 TrackNumber, Rational EditRate, std::string TrackName = "Descriptive Track", UInt32 TrackID = 0)
        {
            static const ULPtr TCDM = new UL(TrackTypeDataDefDM);
            return AddTrack(TCDM, TrackNumber, EditRate, TrackName, TrackID);
        }

        TrackPtr AddDMTrack(std::string TrackName = "Descriptive Track", UInt32 TrackID = 0) { return AddDMTrack(0, TrackName, TrackID); }
        TrackPtr AddDMTrack(UInt32 TrackNumber, std::string TrackName = "Descriptive Track", UInt32 TrackID = 0)
        {
            static const ULPtr TCDM = new UL(TrackTypeDataDefDM);
            return AddTrack(TCDM, TrackNumber, TrackName, TrackID);
        }

        void RemoveTrack(TrackPtr &Track);

        void UpdateDurations(void);


        static PackagePtr GetPackage(MDObjectPtr Object);

        static PackagePtr Parse(MDObjectPtr BaseObject);
    };
}


namespace mxflib
{
    class Metadata : public ObjectInterface, public RefCount<Metadata>
    {
    public:
        PackageList Packages;                       

    protected:
        std::string ModificationTime;               

        Metadata(MDObjectPtr BaseObject) : ObjectInterface(BaseObject) {}

    public:
        Metadata();
        Metadata(std::string TimeStamp);
        void Init(void);

        // Update the modification time for this file and any new packages
        void SetTime(void) { ModificationTime = Now2String(); }
        void SetTime(std::string TimeStamp) { ModificationTime = TimeStamp; }

        void AddDMScheme(ULPtr Scheme)
        {
            DataChunk SchemeValue;
            SchemeValue.Set(16, Scheme->GetValue());

            // Get a list of current schemes
            MDObjectPtr SchemeList = Object->Child(DMSchemes_UL);

            // Scan the list to see if we already have this one
            MDObjectULList::iterator it = SchemeList->begin();
            while(it != SchemeList->end())
            {
                if(SchemeValue == *((*it).second->PutData())) return;
                it++;
            }

            // New scheme, so add it
            Object->Child(DMSchemes_UL)->AddChild()->SetValue(SchemeValue);
        }


        void AddEssenceType(ULPtr ECType) { AddEssenceType(*ECType); };


        void AddEssenceType(const UL &ECType)
        {
            DataChunk ECTypeValue;
            ECTypeValue.Set(16, ECType.GetValue());

            // Get a list of known containers
            MDObjectPtr ECTypeList = Object->Child(EssenceContainers_UL);

            // Scan the list to see if we already have this type
            MDObjectULList::iterator it = ECTypeList->begin();
            while(it != ECTypeList->end())
            {
                if(ECTypeValue == *((*it).second->PutData())) return;
                it++;
            }

            // New type, so add it
            Object->Child(EssenceContainers_UL)->AddChild()->SetValue(ECTypeValue);
        }

        void SetOP(const UL &OP)
        {
            MDObjectPtr Ptr = Object->AddChild(OperationalPattern_UL);
            Ptr->ReadValue(OP.GetValue(), 16);
        }

        void SetOP(ULPtr OP) { SetOP(*OP); }

        // Add a material package to the metadata
        PackagePtr AddMaterialPackage(UMIDPtr PackageUMID) { return AddPackage(MaterialPackage_UL, "", PackageUMID); }
        PackagePtr AddMaterialPackage(std::string PackageName = "", UMIDPtr PackageUMID = NULL) { return AddPackage(MaterialPackage_UL, PackageName, PackageUMID); }

        // Add a top-level file package to the metadata
        PackagePtr AddFilePackage(UInt32 BodySID, UMIDPtr PackageUMID) { return AddPackage(SourcePackage_UL, "", PackageUMID, BodySID); }
        PackagePtr AddFilePackage(UInt32 BodySID, std::string PackageName = "", UMIDPtr PackageUMID = NULL) { return AddPackage(SourcePackage_UL, PackageName, PackageUMID, BodySID); }

        // Add a lower-level source package to the metadata
        PackagePtr AddSourcePackage(UInt32 BodySID, UMIDPtr PackageUMID) { return AddPackage(SourcePackage_UL, "", PackageUMID, BodySID); }
        PackagePtr AddSourcePackage(UInt32 BodySID, std::string PackageName = "", UMIDPtr PackageUMID = NULL) { return AddPackage(SourcePackage_UL, PackageName, PackageUMID, BodySID); }

        bool AddEssenceContainerData(UMIDPtr TheUMID, UInt32 BodySID, UInt32 IndexSID = 0);

        void SetPrimaryPackage(PackagePtr Package) { SetPrimaryPackage(Package->Object); }

        void SetPrimaryPackage(MDObjectPtr Package)
        {
            MDObjectPtr Ptr = Object->Child(PrimaryPackage_UL);
            if(!Ptr) Ptr = Object->AddChild(PrimaryPackage_UL);
            Ptr->MakeRef(Package);
        }

        PackagePtr GetPrimaryPackage(void);

        bool UpdateGenerations(MDObjectPtr Ident, std::string UpdateTime = "");


        static MetadataPtr GetMetadata(MDObjectPtr Object);

        static MetadataPtr Parse(MDObjectPtr BaseObject);

    private:
        PackagePtr AddPackage(const UL &PackageType, std::string PackageName, UMIDPtr PackageUMID, UInt32 BidySID = 0);

        bool UpdateGenerations_Internal(MDObjectPtr Obj, UUIDPtr ThisGeneration);

        void ClearModified_Internal(MDObjectPtr Obj);
    };
}




// These simple inlines need to be defined after the classes
namespace mxflib
{
inline MDObjectPtr PackagePtr::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr PackagePtr::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr PackagePtr::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr PackagePtr::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr PackageParent::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr PackageParent::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr PackageParent::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr PackageParent::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr TrackPtr::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr TrackPtr::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr TrackPtr::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr TrackPtr::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr TrackParent::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr TrackParent::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr TrackParent::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr TrackParent::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr SourceClipPtr::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr SourceClipPtr::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr SourceClipPtr::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr SourceClipPtr::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr DMSourceClipPtr::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr DMSourceClipPtr::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr DMSourceClipPtr::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr DMSourceClipPtr::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr MetadataPtr::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr MetadataPtr::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr MetadataPtr::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr MetadataPtr::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
inline MDObjectPtr DMSegmentPtr::operator[](const char *ChildName) { return GetPtr()->Object[ChildName]; }
inline MDObjectPtr DMSegmentPtr::operator[](MDOTypePtr ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr DMSegmentPtr::operator[](const UL &ChildType) { return GetPtr()->Object[ChildType]; }
inline MDObjectPtr DMSegmentPtr::operator[](ULPtr &ChildType) { return GetPtr()->Object[*ChildType]; }
}

#endif // MXFLIB__METADATA_H

---