ConfigDB/src/include/ConfigDB/Store.h

Go to the documentation of this file.

 
#pragma once
 
#include "Object.h"
#include "Array.h"
#include "ObjectArray.h"
#include "Union.h"
#include "Pool.h"
 
#if DEBUG_VERBOSE_LEVEL == DBG
#include <debug_progmem.h>
#define CFGDB_DEBUG(fmt, ...) debug_e("[CFGDB] %s() %s %p" fmt, __FUNCTION__, getName().c_str(), this, ##__VA_ARGS__);
#else
#define CFGDB_DEBUG(...)
#endif
 
namespace ConfigDB
{
class Database;
 
class Store : public Object
{
public:
    Store(Database& db) : Object(), db(db)
    {
    }
 
    Store(Database& db, const PropertyInfo& propinfo);
 
    explicit Store(const Store& store);
 
    Store(Store&&) = delete;
 
    ~Store();
 
    String getFileName() const
    {
        String name = getName();
        return name.length() ? name : F("_root");
    }
 
    String getFilePath() const;
 
    Database& getDatabase() const
    {
        return db;
    }
 
    uint8_t* getRootData()
    {
        if(!writeCheck()) {
            return nullptr;
        }
        dirty = true;
        return rootData.get();
    }
 
    const uint8_t* getRootData() const
    {
        return rootData.get();
    }
 
    void clear();
 
    String getValueString(const PropertyInfo& info, const void* data) const;
    bool parseString(const PropertyInfo& prop, PropertyData& dst, const PropertyData* defaultData, const char* value,
                     uint16_t valueLength);
 
    const StringPool& getStringPool() const
    {
        return stringPool;
    }
 
    const ArrayPool& getArrayPool() const
    {
        return arrayPool;
    }
 
    bool isLocked() const
    {
        return updaterCount != 0;
    }
 
    static uint8_t getInstanceCount()
    {
        return instanceCount;
    }
 
    bool writeCheck() const;
 
    using Object::exportToFile;
 
    bool exportToFile(const Format& format) const
    {
        String filename = getFilePath() + format.getFileExtension();
        return exportToFile(format, filename);
    }
 
    using Object::importFromFile;
 
    Status importFromFile(const Format& format)
    {
        String filename = getFilePath() + format.getFileExtension();
        return importFromFile(format, filename);
    }
 
    bool isDirty() const
    {
        return dirty;
    }
 
    bool commit();
 
    static StoreUpdateRef lock(StoreRef& store);
 
protected:
    friend class Object;
    friend class ArrayBase;
    friend class Database;
    friend class StoreRef;
    friend class StoreUpdateRef;
 
    void checkRef(const StoreRef& ref);
 
    void queueUpdate(Object::UpdateCallback&& callback);
 
    void clearDirty()
    {
        dirty = false;
    }
 
    void incUpdate();
 
    void decUpdate();
 
    ArrayPool arrayPool;
    StringPool stringPool;
 
private:
    Database& db;
    std::unique_ptr<uint8_t[]> rootData;
    uint8_t updaterCount{};
    bool dirty{};
    static uint8_t instanceCount;
};
 
} // namespace ConfigDB