baseblobbuilder.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/


#pragma once


#include "gwnavruntime/blob/blobbuffer.h"
#include "gwnavruntime/kernel/SF_Std.h"
#include <assert.h>


namespace Kaim
{


template<class T>
class BaseBlobBuilder : public NewOverrideBase<MemStat_BlobBuilder>
{
public:
    typedef T BlobType;

    BaseBlobBuilder(KyInt32 memStat = Stat_Default_Mem, MemoryHeap* heap = nullptr)
        : m_blobBuffer(nullptr)
        , m_blob(nullptr)
        , m_buildingPart(BUILDING_SHALLOW_PART)
        , m_shallowBlobSize(0)
        , m_memStat(memStat)
        , m_heap(heap)
    {}

    bool IsWriteMode() { return m_blobBuffer->IsWriteMode(); }

    T* Build(BlobHandler<T>& blobHandler);

    KyUInt32 ComputeBlobSize();

    void BuildFlatBlob(T& blob);

    virtual ~BaseBlobBuilder() {}

private:
    virtual void DoBuild() = 0;

public:
    void DoBuildAllocatedBlob(BlobBuffer* blobBuffer, T* blob);

    void DoAllocAndBuildReferencedBlob(BlobBuffer* blobBuffer, BlobRef<T>* blobRef);

    BlobBuffer* GetBlobBufferToBuildThis()
    {
        const bool isBuildingShallowPart = (m_buildingPart == BUILDING_SHALLOW_PART);

        KY_DEBUG_ASSERTN(isBuildingShallowPart,
            ("In BaseBlobBuilder::DoBuild(), BUILD_REFERENCED_BLOB must be called after all calls to BLOB_ARRAY, BLOB_ARRAY_COPY, BLOB_STRING, BLOB_BUILD"));

        return (isBuildingShallowPart) ? m_blobBuffer : nullptr;
    }

    BlobBuffer* GetBlobBufferToBuildReference()
    {
        EndShallowPart();
        m_buildingPart = BUILDING_DEEP_PART;
        return m_blobBuffer;
    }

    void EndShallowPart()
    {
        if (m_buildingPart == BUILDING_SHALLOW_PART)
        {
            assert(m_shallowBlobSize == 0); // should not be called twice
            m_shallowBlobSize = m_blobBuffer->m_offset;
        }
        else // (m_buildingPart == BUILDING_DEEP_PART)
        {
            m_blobBuffer->SetBlobRefInfoFromCurrentOffset();
        }
    }

public:
    BlobBuffer* m_blobBuffer;

    T* m_blob;

    enum BuildingPart { BUILDING_SHALLOW_PART = 0, BUILDING_DEEP_PART = 1 };
    BuildingPart m_buildingPart;

    KyUInt32 m_shallowBlobSize;

    KyInt32 m_memStat;
    MemoryHeap* m_heap;
};


#define BLOB_SET(blob, value) \
if (this->IsWriteMode()) (blob) = (value)

#define BLOB_ARRAY(blobArray, count) \
this->GetBlobBufferToBuildThis()->AllocArray(this->IsWriteMode() ? &(blobArray) : nullptr, count)

#define BLOB_ARRAY_COPY(blobArray, src, count) \
this->GetBlobBufferToBuildThis()->AllocAndCopyArray(this->IsWriteMode() ? &(blobArray) : nullptr, (count) != 0 ? (src) : nullptr, (KyUInt32)(count))

#define BLOB_ARRAY_COPY_2(blobArray, ky_array) \
BLOB_ARRAY_COPY(blobArray, ky_array.GetDataPtr(), ky_array.GetSize())

#define BLOB_STRING(str, src) \
this->GetBlobBufferToBuildThis()->AllocAndCopyArray(this->IsWriteMode() ? &(str) : nullptr, src, (KyUInt32)Kaim::SFstrlen(src) + 1)

#define BLOB_BUILD(blob, builder) \
builder.DoBuildAllocatedBlob(this->GetBlobBufferToBuildThis(), this->IsWriteMode() ? &(blob) : nullptr)
// alias
#define BUILD_BLOB(blob, builder) BLOB_BUILD(blob, builder)

#define BUILD_REFERENCED_BLOB(blobRef, builder) \
builder.DoAllocAndBuildReferencedBlob(this->GetBlobBufferToBuildReference(), this->IsWriteMode() ? &(blobRef) : nullptr)

#define COPY_REFERENCED_BLOB(blobRef, srcBlob, srcBlobDeepSize, srcBlobShallowSize)     \
this->GetBlobBufferToBuildReference()->AllocAndCopyReferencedBlob(                      \
    this->IsWriteMode() ? &(blobRef) : nullptr, srcBlob, srcBlobDeepSize, srcBlobShallowSize)

#define COPY_REFERENCED_BLOB_FROM_HANDLER(blobRef, blobHandler)                          \
this->GetBlobBufferToBuildReference()->AllocAndCopyReferencedBlobFromBlobHandler(        \
    this->IsWriteMode() ? &(blobRef) : nullptr, blobHandler)


// --------------------------------- inline implementation ---------------------------------

template<class T>
T* BaseBlobBuilder<T>::Build(BlobHandler<T>& blobHandler)
{
    BlobBuffer blobBuffer;
    m_blobBuffer = &blobBuffer;

    // COUNT
    m_blobBuffer->Alloc<T>();
    m_buildingPart = BUILDING_SHALLOW_PART;
    m_shallowBlobSize = 0;
    DoBuild();

    // ALLOCATE
    m_blobBuffer->SwitchToWriteMode(blobHandler, m_shallowBlobSize, m_heap, m_memStat);

    // WRITE
    m_blob = m_blobBuffer->Alloc<T>();
    m_buildingPart = BUILDING_SHALLOW_PART;
    m_shallowBlobSize = 0;
    DoBuild();

    return (T*)m_blob;
}

template<class T>
KyUInt32 BaseBlobBuilder<T>::ComputeBlobSize()
{
    BlobBuffer blobBuffer;
    m_blobBuffer = &blobBuffer;

    // COUNT
    m_blobBuffer->m_offset += sizeof(T); // what m_blobBuffer->Alloc<T>(); does in COUNT mode
    m_buildingPart = BUILDING_SHALLOW_PART;
    m_shallowBlobSize = 0;
    DoBuild();

    m_shallowBlobSize = 0;

    return m_blobBuffer->m_offset;
}


template<class T>
void BaseBlobBuilder<T>::BuildFlatBlob(T& blob)
{
    m_blob = &blob;
    DoBuild();
}


template<class T>
void BaseBlobBuilder<T>::DoBuildAllocatedBlob(BlobBuffer* blobBuffer, T* blob)
{
    m_blobBuffer = blobBuffer;
    m_blob = blob;
    DoBuild();
}


template<class T>
void BaseBlobBuilder<T>::DoAllocAndBuildReferencedBlob(BlobBuffer* blobBuffer, BlobRef<T>* blobRef)
{
    m_blobBuffer = blobBuffer;

    m_blobBuffer->BeginBlobRefBuffer(blobRef);

    m_blob = m_blobBuffer->Alloc<T>();
    DoBuild();

    m_blobBuffer->SetBlobRefInfoFromCurrentOffset();
}


}