partition.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__PARTITION_H
#define MXFLIB__PARTITION_H

#include <mxflib/primer.h>

#include <list>

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

    class PartitionPtr : public SmartPtr<Partition>
    {
    public:
        PartitionPtr() : SmartPtr<Partition>() {};
//      PartitionPtr(Partition * ptr) : SmartPtr<Partition>(ptr) {};
//      PartitionPtr(MDObjectPtr ptr) : SmartPtr<Partition>((Partition *)ptr.GetPtr()) {};
        PartitionPtr(IRefCount<Partition> * ptr) : SmartPtr<Partition>(ptr) {};

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

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

    typedef std::list<PartitionPtr> PartitionList;
}

namespace mxflib
{
    class Partition : public ObjectInterface, public RefCount<Partition>
    {
    public:
        PrimerPtr PartitionPrimer;      

        MDObjectList AllMetadata;       
        MDObjectList TopLevelMetadata;  

    private:
        std::map<UUID, MDObjectPtr> RefTargets;             
        std::multimap<UUID, MDObjectPtr> UnmatchedRefs;     

    public:
        Partition(const char *BaseType) { Object = new MDObject(BaseType); };
        Partition(MDOTypePtr BaseType) { Object = new MDObject(BaseType); };
        Partition(const UL &BaseUL) { Object = new MDObject(BaseUL); };
        Partition(ULPtr BaseUL) { Object = new MDObject(*BaseUL); };

        void UpdateMetadata(ObjectInterface *NewObject) { ClearMetadata(); AddMetadata(NewObject->Object); };

        void UpdateMetadata(MDObjectPtr NewObject) { ClearMetadata(); AddMetadata(NewObject); };


        void AddMetadata(ObjectInterface *NewObject) { AddMetadata(NewObject->Object); };
        void AddMetadata(MDObjectPtr NewObject);

        void ClearMetadata(void)
        {
            PartitionPrimer = NULL;
            AllMetadata.clear();
            TopLevelMetadata.clear();
            RefTargets.clear();
            UnmatchedRefs.clear();
        }

        Length ReadMetadata(void);

        Length ReadMetadata(MXFFilePtr File, Length Size);

        MetadataPtr ParseMetadata(void);

        MDObjectListPtr ReadIndex(void);

        MDObjectListPtr ReadIndex(MXFFilePtr File, UInt64 Size);


        bool ReadIndex(IndexTablePtr Table);

        DataChunkPtr ReadIndexChunk(void);

        void SetKAG(UInt64 KAG)
        {
            MDObjectPtr Ptr = Object[KAGSize_UL];
            ASSERT(Ptr);
            Ptr->SetUInt64(KAG);
        }

        // Access functions for the reference resolving properties
        // DRAGONS: These should be const, but can't make it work!
        std::map<UUID, MDObjectPtr>& GetRefTargets(void) { return RefTargets; };
        std::multimap<UUID, MDObjectPtr>& GetUnmatchedRefs(void) { return UnmatchedRefs; };

        bool IsComplete(void);

        bool IsClosed(void);


        bool IsMetadataComplete(void)
        {
            warning("Partition::IsMetadataComplete() not yet implemented\n");
            return false;
        }

        bool SeekEssence(void);

        MDObjectParent FindLinkParent(MDObjectPtr &Child);

        MDObjectParent FindLinkParent(MDObjectParent &Child) 
        { 
            MDObjectPtr Obj = &(*Child);
            return FindLinkParent(Obj);
        }

    // Sequential access to the Elements of the Body

    public:
        // goto start of body...set the member variables _BodyLocation, _NextBodyLocation
        bool StartElements();
        // goto _NextBodyLocation
        KLVObjectPtr NextElement();
        // skip over a KLV packet

    protected:
        UInt64 Skip( UInt64 start );
        // skip over any KLVFill
        // DRAGONS: does not iterate - only copes with single KLVFill
        UInt64 SkipFill( UInt64 start );

    private:
        UInt64 _BodyLocation;               // file position for current Element
        UInt64 _NextBodyLocation;       // file position for Element after this

    private:
        void ProcessChildRefs(MDObjectPtr ThisObject);
    };
}

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

#endif // MXFLIB__PARTITION_H

---