Libraries/ConfigDB/src/include/ConfigDB/Object.h

Go to the documentation of this file.

 
#pragma once
 
#include "Property.h"
#include "ObjectInfo.h"
#include "StoreRef.h"
#include "Format.h"
 
namespace ConfigDB
{
class Database;
class Store;
 
class Object
{
public:
    Object() : propinfoPtr(&PropertyInfo::empty)
    {
    }
 
    Object(const Object& other)
    {
        *this = other;
    }
 
    Object(Object&&) = delete;
 
    Object& operator=(const Object& other);
 
    explicit Object(const PropertyInfo& propinfo) : propinfoPtr(&propinfo)
    {
    }
 
    Object(Object& parent, const PropertyInfo& prop, uint16_t dataRef)
        : propinfoPtr(&prop), parent(&parent), dataRef(dataRef)
    {
    }
 
    Object(const Object& parent, const PropertyInfo& prop, uint16_t dataRef)
        : Object(const_cast<Object&>(parent), prop, dataRef)
    {
    }
 
    Object(Object& parent, unsigned propIndex, uint16_t dataRef = 0)
        : Object(parent, parent.typeinfo().getObject(propIndex), dataRef)
    {
    }
 
    Object(const Object& parent, unsigned propIndex, uint16_t dataRef = 0)
        : Object(const_cast<Object&>(parent), propIndex, dataRef)
    {
    }
 
    explicit operator bool() const
    {
        return propinfoPtr->type == PropertyType::Object;
    }
 
    bool typeIs(ObjectType type) const
    {
        return *this && typeinfo().type == type;
    }
 
    bool isArray() const
    {
        return typeinfo().isArray();
    }
 
    bool isStore() const
    {
        return !parent;
    }
 
    Store& getStore();
 
    const Store& getStore() const
    {
        return const_cast<Object*>(this)->getStore();
    }
 
    Database& getDatabase();
 
    const Database& getDatabase() const
    {
        return const_cast<Object*>(this)->getDatabase();
    }
 
    unsigned getObjectCount() const;
 
    Object getObject(unsigned index);
 
    const Object getObject(unsigned index) const
    {
        return const_cast<Object*>(this)->getObject(index);
    }
 
    Object findObject(const char* name, size_t length);
 
    unsigned getPropertyCount() const;
 
    Property getProperty(unsigned index);
 
    PropertyConst getProperty(unsigned index) const;
 
    Property findProperty(const char* name, size_t length);
 
    void clear();
 
    void loadArrayDefaults();
 
    void resetToDefaults();
 
    bool commit();
 
    void clearDirty();
 
    String getName() const;
 
    String getPath() const;
 
    size_t printTo(Print& p) const;
 
    bool exportToStream(const Format& format, Print& output, const ExportOptions& options = {}) const
    {
        return format.exportToStream(*this, output, options);
    }
 
    bool exportToFile(const Format& format, const String& filename, const ExportOptions& options = {}) const;
 
    Status importFromStream(const Format& format, Stream& source)
    {
        return format.importFromStream(*this, source);
    }
 
    Status importFromFile(const Format& format, const String& filename);
 
    const PropertyInfo& propinfo() const
    {
        return *propinfoPtr;
    }
 
    const ObjectInfo& typeinfo() const
    {
        return *this ? *propinfoPtr->variant.object : ObjectInfo::empty;
    }
 
    PropertyData* getPropertyData(unsigned index)
    {
        return PropertyData::fromStruct(typeinfo().getProperty(index), getDataPtr());
    }
 
    const PropertyData* getPropertyData(unsigned index) const
    {
        return PropertyData::fromStruct(typeinfo().getProperty(index), getDataPtr());
    }
 
    using UpdateCallback = Delegate<void(Store& store)>;
 
    void queueUpdate(UpdateCallback callback);
 
protected:
    StoreRef openStore(Database& db, unsigned storeIndex);
    StoreUpdateRef openStoreForUpdate(Database& db, unsigned storeIndex);
 
    void disposeArrays();
    void initArrays();
 
    bool isWriteable() const;
 
    StoreUpdateRef lockStore(StoreRef& store);
 
    bool writeCheck() const;
 
    void* getDataPtr();
 
    const void* getDataPtr() const;
 
    String getPropertyString(unsigned index, StringId id) const;
 
    String getPropertyString(unsigned index) const;
 
    StringId getStringId(const PropertyInfo& prop, const char* value, uint16_t valueLength);
 
    StringId getStringId(const PropertyInfo& prop, const String& value)
    {
        return value ? getStringId(prop, value.c_str(), value.length()) : 0;
    }
 
    template <typename T> StringId getStringId(const PropertyInfo& prop, const T& value)
    {
        return getStringId(prop, toString(value));
    }
 
    int findStringId(const char* value, uint16_t valueLength) const;
 
    void setPropertyValue(unsigned index, const void* value);
    void setPropertyValue(unsigned index, const String& value);
 
    const PropertyInfo* propinfoPtr;
    Object* parent{};
    uint16_t dataRef{}; //< Relative to parent
 
public:
    uint16_t streamPos{}; //< Used during streaming
};
 
template <class ClassType> class ObjectTemplate : public Object
{
public:
    using Object::Object;
};
 
template <class UpdaterType, class ClassType> class ObjectUpdaterTemplate : public ClassType
{
public:
    using ClassType::ClassType;
 
    explicit operator bool() const
    {
        return Object::operator bool() && this->isWriteable();
    }
};
 
template <class UpdaterType, class DatabaseClassType, unsigned storeIndex, class ParentClassType, unsigned propIndex,
          unsigned offset>
class OuterObjectUpdaterTemplate : public UpdaterType
{
public:
    OuterObjectUpdaterTemplate(StoreUpdateRef store)
        : UpdaterType(*store, ParentClassType::typeinfo.getObject(propIndex), offset), store(store)
    {
    }
 
    explicit OuterObjectUpdaterTemplate(DatabaseClassType& db)
        : OuterObjectUpdaterTemplate(this->openStoreForUpdate(db, storeIndex))
    {
    }
 
    std::unique_ptr<ImportStream> createImportStream(const Format& format)
    {
        return format.createImportStream(store, *this);
    }
 
    explicit operator bool() const
    {
        return store && UpdaterType::operator bool();
    }
 
private:
    StoreUpdateRef store;
};
 
template <class ContainedClassType, class UpdaterType, class DatabaseClassType, unsigned storeIndex,
          class ParentClassType, unsigned propIndex, unsigned offset>
class OuterObjectTemplate : public ContainedClassType
{
public:
    OuterObjectTemplate(StoreRef store)
        : ContainedClassType(*store, ParentClassType::typeinfo.getObject(propIndex), offset), store(store)
    {
    }
 
    OuterObjectTemplate(DatabaseClassType& db) : OuterObjectTemplate(this->openStore(db, storeIndex))
    {
    }
 
    std::unique_ptr<ExportStream> createExportStream(const Format& format, const ExportOptions& options = {}) const
    {
        return format.createExportStream(store, *this, options);
    }
 
    using OuterUpdater =
        OuterObjectUpdaterTemplate<UpdaterType, DatabaseClassType, storeIndex, ParentClassType, propIndex, offset>;
 
    OuterUpdater update()
    {
        return OuterUpdater(this->lockStore(store));
    }
 
    bool update(Delegate<void(UpdaterType)> callback)
    {
        if(auto upd = update()) {
            callback(upd);
            return true;
        }
        this->queueUpdate([callback](Store& store) {
            callback(UpdaterType(store, ParentClassType::typeinfo.getObject(propIndex), offset));
        });
        return false;
    }
 
private:
    StoreRef store;
};
 
} // namespace ConfigDB