workingmemcontainerbase.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/querysystem/workingmemory.h"
#include <string.h>

namespace Kaim
{

// TODO
// Rename to WorkingMemBuffer
// Put code relative to the buffer in this call and NOT in WorkingMemory
// put code in a .cpp, especially what uses workingMemory
class WorkingMemContainerBase
{
public:
    WorkingMemContainerBase() : m_workingMemory(nullptr), m_bufferIdx(BufferIndex_Invalid) {}
    WorkingMemContainerBase(WorkingMemory* workingMemory) : m_workingMemory(nullptr), m_bufferIdx(BufferIndex_Invalid) { Init(workingMemory); }
    ~WorkingMemContainerBase() { ReleaseBuffer(); }

    KyResult Init(WorkingMemory* workingMemory)
    {
        ReleaseBuffer();

        BufferIndex bufferIdx = workingMemory->TakeUsageOfFirstUnusedBufferIdx();

        if (bufferIdx == BufferIndex_Invalid)
            return KY_ERROR;

        m_workingMemory = workingMemory;
        m_bufferIdx = bufferIdx;

        if (workingMemory->GetBuffer(bufferIdx) == nullptr)
        {
            if (workingMemory->AllocBiggerBuffer(bufferIdx) == nullptr)
            {
                return KY_ERROR;
            }
        }

        return KY_SUCCESS;
    }

    bool IsInitialized() const { return m_workingMemory != nullptr; }

    void* GetBuffer() const { return m_workingMemory->GetBuffer(m_bufferIdx); }
    KyUInt32 GetBufferSize() const { return m_workingMemory->GetBufferSize(m_bufferIdx); }

    char* GetDataPtr() const { return (char*)m_workingMemory->GetBuffer(m_bufferIdx); } // same as GetBuffer() but with a much better name
    KyUInt32 GetCapacity() const { return m_workingMemory->GetBufferSize(m_bufferIdx); } // same as GetBufferSize() but with a much better name

    // AllocBiggerBuffer DOES NOT memcpy the previous buffer content...
    // newMinByteSize == 0 means no specific size is wanted, this will use granularity to compute a new size
    void* AllocBiggerBuffer(KyUInt32 newMinByteSize = 0) { return m_workingMemory->AllocBiggerBuffer(m_bufferIdx, newMinByteSize); }

    // memcpy the previous buffer content
    void* Realloc(KyUInt32 oldSize, KyUInt32 newSize)
    {
        void* oldBuffer = GetBuffer();

        if (newSize <= GetBufferSize())
            return oldBuffer;

        void* newBuffer = AllocBiggerBuffer(newSize);
        if (newBuffer == nullptr)
            return nullptr;

        memcpy(newBuffer, oldBuffer, oldSize);

    #if defined(KY_BUILD_DEBUG)
        memset(oldBuffer, 0xAB, oldSize);
    #endif

        ReleaseMemory(oldBuffer);
        return newBuffer;
    }

    void ReleaseMemory(void* memory) { m_workingMemory->ReleaseMemory(memory); }

    // free the idx in the Working Memory
    void ReleaseBuffer()
    {
        if (m_workingMemory != nullptr)
        {
            m_workingMemory->ReleaseBuffer(m_bufferIdx);

            m_workingMemory = nullptr;
            m_bufferIdx = BufferIndex_Invalid;
        }
    }

public:
    WorkingMemory* m_workingMemory;
    BufferIndex m_bufferIdx;
};


}