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   //16 Byte per key value pair
                {
                    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