YiPersistentStore.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_PERSISTENT_STORE_H_
#define _YI_PERSISTENT_STORE_H_

#include "binding/YiScriptableObject.h"
#include "framework/YiPredef.h"
#include "logging/YiLoggerHelper.h"
#include "signal/YiSignal.h"
#include "thread/YiAutoMutex.h"
#include "utility/YiString.h"
#include "utility/YiUtilities.h"
class IYIPersistentStorePriv;
class CYIPersistentStore : public CYIScriptableObject
{
public:
    enum STORE_ERROR
    {
        STORE_ERROR_OK = 0,
        STORE_ERROR_NOT_FOUND,
        STORE_ERROR_CORRUPTED,
        STORE_ERROR_NOT_ENOUGH_SPACE,
        STORE_ERROR_BAD_PARAMETERS,
        STORE_ERROR_UNKNOWN
    };

    CYIPersistentStore(uint64_t uMaxSizeInBytes = 0);
    CYIPersistentStore(const CYIPersistentStore &rRHS);
    virtual ~CYIPersistentStore();

    CYIPersistentStore &operator=(const CYIPersistentStore &rRHS);

    template <typename T> void      Add(const CYIString &Key, const T &value);

    template <typename T> bool      Find(const CYIString &Key, T *value) const; 

    void                            Remove(const CYIString &key);

    void                            Clear();

    bool     Save(const CYIString &sFile);

    bool     Load(const CYIString &sFile);

    void     RequestSave(const CYIString &sFile);

    void     RequestLoad(const CYIString &sFile);

    bool     Clear(const CYIString &sFile);

    STORE_ERROR GetLastErrorCode() const;

    // 
    CYISignal<bool> SaveCompleted;

    // 
    CYISignal<bool> LoadCompleted;

private:
    std::map<CYIString, CYIString>  m_StateData;
    uint64_t m_uPersistentStoreMaxSize;
    STORE_ERROR m_lastErrorCode;
    mutable CYIRecursiveMutex m_StateDataMutex;

    IYIPersistentStorePriv *m_pPriv;
    friend class IYIPersistentStorePriv;
};

template <typename T>
inline
void CYIPersistentStore::Add(const CYIString &Key, const T &value)
{
    bool bError = false;
    CYIString StringValue = CYIString::FromValue(value, &bError);
    if (!bError)
    {
        CYIAutoMutex locker(m_StateDataMutex);

        m_StateData[Key] = StringValue;
    }
    else
    {
        YI_LOGE("CYIPersistentStore", "Add failed for key [%s], conversion of value to string failed.", Key.GetData());
    }
}

template <typename T>
inline
bool CYIPersistentStore::Find(const CYIString &Key, T *value) const
{
    CYIAutoMutex locker(m_StateDataMutex);
    bool bValueFound = false;
    std::map<CYIString, CYIString>::const_iterator KeyValue = m_StateData.find(Key);
    if (KeyValue != m_StateData.end())
    {
        CYIString sValue = KeyValue->second;
        bool bError = false;
        T temporary = sValue.To<T>(&bError);
        if (!bError)
        {
            *value = temporary;
            bValueFound = true;
        }
        else
        {
            YI_LOGE("CYIPersistentStore", "Value was found for key [%s] but conversion from string failed.", Key.GetData());
        }
    }
    
    return bValueFound;
}

#endif // _YI_PERSISTENT_STORE_H_