Database.h

Go to the documentation of this file.

 
#pragma once
 
#include "Store.h"
#include "DatabaseInfo.h"
#include <Data/CString.h>
#include <WVector.h>
 
namespace ConfigDB
{
class Database
{
public:
    Database(const DatabaseInfo& typeinfo, const String& path)
        : typeinfo(typeinfo), path(path.c_str()), updateRefs(new WeakRef[typeinfo.storeCount])
    {
    }
 
    virtual ~Database();
 
    String getName() const
    {
        auto pathstr = path.c_str();
        auto sep = strrchr(pathstr, '/');
        return sep ? &sep[1] : pathstr;
    }
 
    String getPath() const
    {
        return path.c_str();
    }
 
    StoreRef openStore(unsigned index);
 
    StoreUpdateRef openStoreForUpdate(unsigned index);
 
    void checkStoreRef(const StoreRef& ref);
 
    void queueUpdate(Store& store, Object::UpdateCallback&& callback);
 
    void checkUpdateQueue(Store& store);
 
    bool save(Store& store) const;
 
    StoreUpdateRef lockStore(StoreRef& store);
 
    virtual const Format& getFormat(const Store& store) const;
 
    virtual bool handleFormatError(FormatError err, const Object& object, const String& arg);
 
    std::unique_ptr<ExportStream> createExportStream(const Format& format, const String& path = nullptr);
 
    size_t exportToStream(const Format& format, Print& output)
    {
        return format.exportToStream(*this, output);
    }
 
    bool exportToFile(const Format& format, const String& filename);
 
    Status importFromStream(const Format& format, Stream& source)
    {
        return format.importFromStream(*this, source);
    }
 
    Status importFromFile(const Format& format, const String& filename);
 
    std::unique_ptr<ImportStream> createImportStream(const Format& format)
    {
        return format.createImportStream(*this);
    }
 
    const DatabaseInfo& typeinfo;
 
private:
    using WeakRef = std::weak_ptr<Store>;
 
    struct StoreCache {
        std::shared_ptr<Store> store;
 
        explicit operator bool() const
        {
            return bool(store);
        }
 
        void reset()
        {
            store.reset();
        }
 
        bool typeIs(const PropertyInfo& storeInfo) const
        {
            return store && store->propinfoPtr == &storeInfo;
        }
 
        bool isIdle()
        {
            return store && store.use_count() == 1;
        }
 
        void resetIf(const DatabaseInfo& info)
        {
            if(!*this) {
                return;
            }
            for(unsigned i = 0; i < info.storeCount; ++i) {
                if(typeIs(info.stores[i])) {
                    reset();
                    break;
                }
            }
        }
    };
 
    struct UpdateQueueItem {
        Database* database;
        uint8_t storeIndex;
        Object::UpdateCallback callback;
 
        bool operator==(const UpdateQueueItem& item) const
        {
            return database == item.database && storeIndex == item.storeIndex;
        }
    };
 
    std::shared_ptr<Store> loadStore(const PropertyInfo& storeInfo);
 
    CString path;
 
    // Hold store open for a brief period to avoid thrashing
    static StoreCache readCache;
    static StoreCache writeCache;
    std::unique_ptr<WeakRef[]> updateRefs;
    static Vector<UpdateQueueItem> updateQueue;
    static bool cacheCallbackQueued;
};
 
template <class ClassType> class DatabaseTemplate : public Database
{
public:
    DatabaseTemplate(const String& path) : Database(ClassType::typeinfo, path)
    {
    }
};
 
} // namespace ConfigDB