DataChunk.h

#ifndef CDATACHUNK_CLASS_H
#define CDATACHUNK_CLASS_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
 
#include "ElementArray.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
typedef unsigned int DataChunkID;
#define DATACHUNK_UNKNOWN ((mootools::DataChunkID)(-1))
 
typedef enum _DATACHUNK_FLAGS
{
    DATACHUNK_NONE = 0x00,
    DATACHUNK_KEEP_ON_COPY = 0x01,
    DATACHUNK_MAIN_CHANNEL = 0x02,
    DATACHUNK_INFO_FLAGS = 0xFF,
 
    // These flags are used when calling CDataChunk methods. Not save in the DataChunkInfo.flags
    DATA_CHUNK_REPLACE_DATA = 0x100, // Use in AddDataChunk to replace a given id with a new one that can have different CElementMethods
} DATACHUNK_FLAGS;
 
class CElementMethods;
class DLL_3DFUNCTION CDataChunk
{
public:
    CDataChunk();
    virtual ~CDataChunk();
    unsigned int AddDataChunk(DataChunkID dataid, CElementMethods *methods, unsigned int flags);
    void AppendDataChunks(const CDataChunk& srcdata, bool emptyData = true); // Add data chunks that are in srcdata if not already in the data chunks information
    void InitDataChunks(const CDataChunk& src, unsigned int size = -1);
    bool RemoveDataChunk(DataChunkID dataid);
    bool HasDataChunk(DataChunkID dataid) const;
 
    int SetGrowFactor(int growFaceMode);
    void PreAllocate(int estimatedSize, bool constructAllElementsOnce = false); // Preallocate array. GetDataSize() return 0. When filling the array, SetDataSize must be called with growOnly = true, otherwise array will be resized loosing the preallocation advantage
    void SetDataSize(unsigned int size, bool growOnly = false, unsigned int growFaceMode = CElementArray::GROW_KEEP_MODE); // Size is the data chunk size, growOnly = false means that the size fits exactly the defined size otherwise the size cannot be reduced and can only increase
    void ExpandDataSize(unsigned int addsize); // Expand the existing size by addsize elements. The method grows the array (if needed), so PreAllocate can be used before.
    unsigned int GetDataSize() const;
    void FreeExtra();
 
    void *GetMainData(unsigned int index) const; // Return data 
    void *GetData(DataChunkID id, unsigned int index) const;
    void DeleteAll();
    void RemoveAll();
 
    unsigned int GetChunksNbr() const;
    HashPos GetFirstChunk() const;
    void GetNextChunk(HashPos& pos, DataChunkID& id) const;
 
    const CElementArray *GetData(unsigned int dataChunkID) const;
    SIZET GetSizeOfDataChunk(DataChunkID dataid) const;
 
    unsigned int CopyData(unsigned int dstindex, unsigned int srcindex, const CDataChunk& srcdata);
    unsigned int CopyData(const CDataChunk& refdata);
 
    bool Reorder(const unsigned int *reforder, unsigned int size, bool moveToDestinationIndexes);
 
    void Serialize(CXArchive& ar);
 
#ifdef _DEBUG
    void Dump(DataChunkID id, unsigned int index) const;
#endif
 
protected:
    typedef struct
    {
        CElementArray *data;
        unsigned int flags;
    } DataChunkInfo;
    typedef CHashMap<DataChunkID, DataChunkID, DataChunkInfo> CDataChunkMap;
 
    bool constructAllOnce;
    unsigned int preallocate;
    unsigned int datasize, growsize;
    CDataChunkMap chunks;
    DataChunkID mainChunkID;
    CElementArray *mainArray;
 
    void UpdateMainChunk();
};
 
///////////////////////////////////////////////////////////////////////////////////
// Inline implementation
inline void *CDataChunk::GetMainData(unsigned int index) const
{
    XASSERT(mainArray);
    return mainArray->ElementAt(index);
}
 
inline void *CDataChunk::GetData(DataChunkID id, unsigned int index) const // Return the data chunk by index
{
    DataChunkInfo *info = chunks.Find(id);
    if (!info)
        return NULL;
 
    return info->data->ElementAt(index);
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // CDATACHUNK_CLASS_H