datachunk.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__DATACHUNK_H
#define MXFLIB__DATACHUNK_H

namespace mxflib
{
    // Forward declare so the class can be used
    class DataChunk;

    typedef SmartPtr<DataChunk> DataChunkPtr;

    typedef std::list<DataChunkPtr> DataChunkList;
}


namespace mxflib
{
    class DataChunk : public RefCount<DataChunk>
    {
    private:
        size_t DataSize;                        
        size_t AllocationGranularity;           
        bool ExternalBuffer;                    

    public:
        size_t Size;                            
        UInt8 *Data;                            

        DataChunk() : DataSize(0), AllocationGranularity(0), ExternalBuffer(false), Size(0), Data(NULL) {};

        DataChunk(size_t BufferSize) : DataSize(0), AllocationGranularity(0), ExternalBuffer(false), Size(0), Data(NULL) { Resize(BufferSize); };

        DataChunk(size_t MemSize, const UInt8 *Buffer) : DataSize(0), AllocationGranularity(0), ExternalBuffer(false), Size(0), Data(NULL) { Set(MemSize, Buffer); };

        template<int SIZE> DataChunk(const Identifier<SIZE> *ID)  : DataSize(0), AllocationGranularity(0), ExternalBuffer(false), Size(0), Data(NULL) { Set(ID->Size(), ID->GetValue() ); }

        DataChunk(const DataChunk &Chunk) : DataSize(0), AllocationGranularity(0), ExternalBuffer(false), Size(0), Data(NULL) { Set(Chunk.Size, Chunk.Data); };

        DataChunk(const DataChunkPtr &Chunk) : DataSize(0), AllocationGranularity(0), ExternalBuffer(false), Size(0), Data(NULL) { Set(Chunk->Size, Chunk->Data); };

        ~DataChunk() 
        { 
            if((!ExternalBuffer) && (Data)) delete[] Data; 
        };

        void Resize(size_t NewSize, bool PreserveContents = true);


        void ResizeBuffer(size_t NewSize, bool PreserveContents = true);


        UInt8 *StealBuffer(bool MakeEmpty = false);

        void Set(const DataChunk &Buffer, size_t Start = 0)
        {
            Set(Buffer.Size, Buffer.Data, Start);
        }

        void Set(const DataChunkPtr &Buffer, size_t Start = 0)
        {
            Set(Buffer->Size, Buffer->Data, Start);
        }

        void Set(size_t MemSize, const UInt8 *Buffer, size_t Start = 0)
        {
            if(Size < (MemSize + Start)) Resize(MemSize + Start);

            memcpy(&Data[Start], Buffer, MemSize);
        }

        void Append(const DataChunk &Buffer)
        {
            Set(Buffer.Size, Buffer.Data, Size);
        }

        void Append(const DataChunkPtr &Buffer)
        {
            Set(Buffer->Size, Buffer->Data, Size);
        }

        void Append(size_t MemSize, const UInt8 *Buffer)
        {
            Set(MemSize, Buffer, Size);
        }

        DataChunk& operator=(const DataChunk &Right)
        {
            Set(Right.Size, Right.Data);

            return *this;
        }

        bool operator==(const DataChunk &Right) const
        {
            if(Size != Right.Size) return false;
            
            if(memcmp(Data, Right.Data, Size) == 0) return true;

            return false;
        }

        bool operator!=(const DataChunk &Right) const { return !operator==(Right); };

        std::string GetString(void);

        void SetGranularity(size_t Gran) { AllocationGranularity = Gran; };
        size_t GetGranularity(void) { return AllocationGranularity; };


        void SetBuffer(UInt8 *Buffer, size_t BuffSize, size_t AllocatedSize = 0);


        bool TakeBuffer(DataChunk &OldOwner, bool MakeEmpty = false);


        bool TakeBuffer(DataChunkPtr &OldOwner, bool MakeEmpty = false);
    };
}

#endif // MXFLIB__DATACHUNK_H

---