Storage.h

Go to the documentation of this file.

/*
 * This file is part of KnowRob, please consult
 * https://github.com/knowrob/knowrob for license details.
 */
 
#ifndef KNOWROB_STORAGE_H
#define KNOWROB_STORAGE_H
 
#include <boost/property_tree/ptree.hpp>
#include "knowrob/semweb/TriplePattern.h"
#include "knowrob/semweb/Triple.h"
#include "knowrob/semweb/TripleContainer.h"
#include "knowrob/semweb/Vocabulary.h"
#include "knowrob/PropertyTree.h"
#include "knowrob/ThreadPool.h"
#include "knowrob/DataSourceHandler.h"
#include "knowrob/plugins/PluginFactory.h"
#include "knowrob/plugins/TypedPluginFactory.h"
 
namespace knowrob {
    enum class StorageFeature : std::uint8_t {
        // A flag that indicates that nothing special is supported.
        NothingSpecial = 1ul << 0,
        // A flag that indicates that re-assignment of variables within query pipelines is supported.
        ReAssignment = 1ul << 2,
        // A flag that indicates that triple context is supported.
        // If this flag is not set, statements with additional context information first must be reified
        // before they can be handled by this backend.
        TripleContext = 1ul << 3
    };
    using StorageFeatures = StorageFeature;
 
    StorageFeature operator|(StorageFeature a, StorageFeature b);
 
    bool operator&(StorageFeature a, StorageFeature b);
 
    class Storage : public DataSourceHandler {
    public:
        explicit Storage(StorageFeatures features = StorageFeature::NothingSpecial) : features_(features), storageLanguage_(PluginLanguage::CPP) {}
 
        virtual ~Storage() = default;
 
        PluginLanguage storageLanguage() const { return storageLanguage_; }
 
        const auto &vocabulary() const { return vocabulary_; }
 
        void setVocabulary(std::shared_ptr<Vocabulary> vocabulary) { vocabulary_ = std::move(vocabulary); }
 
        bool supports(StorageFeature feature) const { return features_ & feature; }
 
        virtual bool insertOne(const Triple &triple) = 0;
 
        virtual bool insertAll(const TripleContainerPtr &triples) = 0;
 
        virtual bool removeOne(const Triple &triple) = 0;
 
        virtual bool removeAll(const TripleContainerPtr &triples) = 0;
 
        virtual bool removeAllWithOrigin(std::string_view origin) = 0;
 
        virtual bool initializeBackend(const PropertyTree &config) = 0;
 
        std::optional<std::string> getVersionOfOrigin(std::string_view origin) const {
            auto it = originVersions_.find(origin.data());
            if (it != originVersions_.end()) {
                return it->second;
            }
            return std::nullopt;
        }
 
        void setVersionOfOrigin(std::string_view origin, std::optional<std::string_view> version) {
            if (version) {
                originVersions_[origin.data()] = version.value().data();
            } else {
                originVersions_.erase(origin.data());
            }
        }
 
    protected:
        std::map<std::string, std::string> originVersions_;
        std::shared_ptr<Vocabulary> vocabulary_;
        StorageFeatures features_;
        PluginLanguage storageLanguage_;
 
        void enableFeature(StorageFeature feature) { features_ = features_ | feature; }
 
        void setStorageLanguage(PluginLanguage storageLanguage) { storageLanguage_ = storageLanguage; }
 
        friend class StorageManager;
    };
 
    using StoragePtr = std::shared_ptr<Storage>;
    using BackendFactory = PluginFactory<Storage>;
    using NamedBackend = NamedPlugin<Storage>;
 
} // knowrob
 
#define KNOWROB_STORAGE_PLUGIN(classType, pluginName) extern "C" { \
        std::shared_ptr<knowrob::DataBackend> knowrob_createPlugin(const std::string &pluginID) \
            { return std::make_shared<classType>(); } \
        const char* knowrob_getPluginName() { return pluginName; } }
 
#endif //KNOWROB_STORAGE_H