hashedvaluemap.h

Go to the documentation of this file.

#pragma once
#include "hashedvaluemap_intf.h"
#include "rawmemory_intf.h"
#include <adtf_utils.h>
 
namespace adtf
{
namespace base
{
namespace ant
{

template<typename STORAGE = adtf::util::cMemoryBlock, typename INTERFACE = IHashValueMap>
class hash_value_map : public INTERFACE
{
private:
    STORAGE m_oStorage;
 
protected:
    size_t m_szPreAllocatedKeyValueSize = 0;
 
public:
#pragma pack(push)
#pragma pack(1)
    struct tHashValueStorageType
    {
        static uint8_t GetVersion()
        {
            return 1;
        }
        tHashValueStorageType(): eType(IHashValueMapValue::HVT_Invalid), nByteSize(0), ui8StorageVersion(GetVersion())
        {
        }
        uint8_t ui8StorageVersion; // we using 8 bit for versioning
        uint8_t nByteSize; // we using 8 bit to restrict the value size
        IHashValueMapValue::tType eType;
        uint8_t nReserved[1];
        IHashValueMap::tHashKey oKey; // for accessing its important to have aligned value
        uint8_t eStorage[8]; // for accessing its important to have aligned value
    };
#pragma pack(pop)
    typedef tHashValueStorageType value_type;
 
private:
    class cHashedValueSetter : public IRawMemory
    {
        tHashValueStorageType* m_pCurrent;
 
    public:
        explicit cHashedValueSetter(tHashValueStorageType* pCurrent): m_pCurrent(pCurrent)
        {
        }
        tResult Set(const void* pData, size_t szSize) override
        {
            if (szSize > 8)
            {
                RETURN_ERROR(ERR_MEMORY);
            }
            else
            {
                m_pCurrent->nByteSize = static_cast<uint8_t>(szSize);
                adtf::util::cMemoryBlock::MemCopy(&m_pCurrent->eStorage[0], pData, szSize);
                RETURN_NOERROR;
            }
        }
 
        const void* Get() const override
        {
            return &m_pCurrent->eStorage[0];
        }
        size_t GetSize() const override
        {
            return static_cast<size_t>(m_pCurrent->nByteSize);
        }
    };
 
    class cHashedValueGetter : public IHashValueMapValue
    {
        tHashValueStorageType* m_pCurrent;
 
    public:
        explicit cHashedValueGetter(tHashValueStorageType* pCurrent): m_pCurrent(pCurrent)
        {
        }
 
        tResult Set(const IHashValueMapValue& /* oValue */) override
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
        tResult FromRaw(const IRawMemory& /* oRawValue */)
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        tResult ToRaw(IRawMemory&& oRawValue) const
        {
            return oRawValue.Set(&m_pCurrent->eStorage[0], static_cast<size_t>(m_pCurrent->nByteSize));
        }
 
        tType GetType() const override
        {
            return (m_pCurrent->eType);
        }
    };
 
public:
    hash_value_map(): m_oStorage()
    {
    }

    hash_value_map(size_t szPreAllocatedKeyValueSize): m_oStorage()
    {
        m_szPreAllocatedKeyValueSize = szPreAllocatedKeyValueSize;
        Reset();
    }

    virtual ~hash_value_map()
    {
    }

    hash_value_map(const hash_value_map& oToCopy): hash_value_map(oToCopy.GetSize())
    {
        m_szPreAllocatedKeyValueSize = oToCopy.m_szPreAllocatedKeyValueSize;
        oToCopy.ToRaw(*this);
    }

    hash_value_map& operator=(const hash_value_map& oToCopy)
    {
        m_szPreAllocatedKeyValueSize = oToCopy.m_szPreAllocatedKeyValueSize;
        oToCopy.ToRaw(*this);
        return *this;
    }

    hash_value_map(hash_value_map&& oToCopy) = delete;
    hash_value_map& operator=(hash_value_map&& oToCopy) = delete;
 
protected:
    hash_value_map(size_t szPreallocateMemorySize, bool bZeroMemory): m_oStorage()
    {
        m_oStorage.Alloc(szPreallocateMemorySize);
        if (szPreallocateMemorySize > 0 && bZeroMemory)
        {
            adtf::util::cMemoryBlock::MemZero(m_oStorage.GetPtr(), szPreallocateMemorySize);
        }
    }
 
public:
    bool Exists(const IHashValueMap::tHashKey& oKey) const override
    {
        value_type* pValue = GetValueT(oKey, nullptr);
        return (pValue != nullptr);
    }
 
    tResult Get(IHashValueMap& oHashMap) const override
    {
        if (oHashMap.GetRawMemoryLayoutVersion() == GetRawMemoryLayoutVersion())
        {
            adtf_memory_buffer<const void> oMem(m_oStorage.GetPtr(), m_oStorage.GetSize());
            return oHashMap.FromRaw(oMem);
        }
        else
        {
            value_type* pKeyValue = reinterpret_cast<value_type*>(m_oStorage.GetPtr());
            size_t szCurrentSize = GetCapacity();
            for (size_t szIdx = 0; szIdx < szCurrentSize; ++szIdx)
            {
                value_type* pCurrentVal = &pKeyValue[szIdx];
                if (pCurrentVal->eType != IHashValueMapValue::HVT_Invalid)
                {
                    cHashedValueGetter oValueGetter(pCurrentVal);
                    RETURN_IF_FAILED(oHashMap.SetValue(pCurrentVal->oKey, oValueGetter));
                }
                else
                {
                    break;
                }
            }
            RETURN_NOERROR;
        }
    }
 
    tResult GetValue(const IHashValueMap::tHashKey& oHashKey, IHashValueMapValue& oValue) const override
    {
        value_type* pValue = GetValueT(oHashKey, nullptr);
        if (pValue)
        {
            cHashedValueGetter oValueGetter(pValue);
            return oValue.Set(oValueGetter);
        }
        else
        {
            RETURN_ERROR(ERR_NOT_FOUND);
        }
    }
 
    void Reset() override
    {
        size_t szNewSize = m_szPreAllocatedKeyValueSize * sizeof(value_type);
        m_oStorage.Alloc(szNewSize);
        if (szNewSize > 0)
        {
            adtf::util::cMemoryBlock::MemZero(m_oStorage.GetPtr(), szNewSize);
        }
    }
 
    tResult SetValue(const IHashValueMap::tHashKey& oHashKey, const IHashValueMapValue& oValue) override
    {
        value_type* pFirstInvalidValue = nullptr;
        value_type* pKeyValue = GetValueT(oHashKey, &pFirstInvalidValue);
        if (pKeyValue != nullptr)
        {
            // use the found to set value
        }
        else
        {
            // use the first invalid
            if (pFirstInvalidValue)
            {
                pKeyValue = pFirstInvalidValue;
            }
            // else append
            else
            {
                size_t szNewLastPos = GetCapacity();
                RETURN_IF_FAILED(m_oStorage.Resize((szNewLastPos + 1) * sizeof(value_type)));
                value_type* pNewFirstValue = reinterpret_cast<value_type*>(m_oStorage.GetPtr());
                pKeyValue = &pNewFirstValue[szNewLastPos];
            }
        }
        pKeyValue->oKey = oHashKey;
        pKeyValue->eType = oValue.GetType();
        pKeyValue->ui8StorageVersion = value_type::GetVersion();
        return oValue.ToRaw(cHashedValueSetter(pKeyValue));
    }

    size_t GetCapacity() const
    {
        return m_oStorage.GetSize() / sizeof(value_type);
    }
 
    bool IsEmpty() const override
    {
        value_type* pNewFirstValue = reinterpret_cast<value_type*>(m_oStorage.GetPtr());
        return !((GetCapacity() > 0) && (pNewFirstValue->eType != IHashValueMapValue::HVT_Invalid));
    }
 
    tResult FromRaw(const IRawMemory& oRawValue) override
    {
        return m_oStorage.Set(oRawValue.Get(), oRawValue.GetSize());
    }
 
    tResult ToRaw(IRawMemory&& oRawValue) const override
    {
        return oRawValue.Set(m_oStorage.GetPtr(), m_oStorage.GetSize());
    }
    uint8_t GetRawMemoryLayoutVersion() const
    {
        return value_type::GetVersion();
    }
    void* GetPtr() const
    {
        return m_oStorage.GetPtr();
    }
 
private:
    value_type* GetValueT(const IHashValueMap::tHashKey& oKey, value_type** ppFirstInvalid) const
    {
        if (ppFirstInvalid)
        {
            *ppFirstInvalid = nullptr;
        }
        value_type* pKeyValue = reinterpret_cast<value_type*>(m_oStorage.GetPtr());
        size_t szCurrentSize = GetCapacity();
        for (size_t szIdx = 0; szIdx < szCurrentSize; ++szIdx)
        {
            if (pKeyValue[szIdx].eType != IHashValueMapValue::HVT_Invalid)
            {
                if (pKeyValue[szIdx].oKey == oKey)
                {
                    return &pKeyValue[szIdx];
                }
            }
            else
            {
                if (ppFirstInvalid && *ppFirstInvalid == nullptr)
                {
                    *ppFirstInvalid = &pKeyValue[szIdx];
                }
            }
        }
        return nullptr;
    }
};

adtf::util::cVariant get_hash_value(const IHashValueMap& oMap,
                                    const IHashValueMap::tHashKey& oHash,
                                    const adtf::util::cVariant oDefault);
tResult set_hash_value(IHashValueMap& oMap, const IHashValueMap::tHashKey& oHash, const adtf::util::cVariant oValue);

IHashValueMap::tHashKey create_hash_value_key(const char* strToHash);
 
} // namespace ant
 
using ant::hash_value_map;
using ant::create_hash_value_key;
using ant::get_hash_value;
using ant::set_hash_value;
 
} // namespace base
} // namespace adtf