registry.hpp

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <string>
#include <filesystem>
 
#include "native.h"
#include <asio.hpp>
#include <absl/container/flat_hash_map.h>
#include <spdlog/spdlog.h>
 
#ifdef interface
    #undef interface
#endif
#include <evmc/evmc.hpp>
#ifndef interface
    #define interface __STRUCT__
#endif
 
#include "utils.hpp"
#include "feature.hpp"
#include "transformation.hpp"
#include "condition.hpp"
#include "file.hpp"
 
namespace dcn
{
    class Registry
    {
        public:
            Registry() = delete;
            Registry(asio::io_context & io_context);
 
            Registry(const Registry&) = delete;
            Registry& operator=(const Registry&) = delete;
            
            ~Registry() = default;
 
            asio::awaitable<bool> addFeature(evmc::address address, Feature feature, evmc::address owner, std::filesystem::path source);
            
            asio::awaitable<std::optional<Feature>> getNewestFeature(const std::string& name) const;
 
            asio::awaitable<std::optional<Feature>> getFeature(const std::string& name, const evmc::address & address) const;
 
            asio::awaitable<bool> addTransformation(evmc::address address, Transformation transformation, evmc::address owner, std::filesystem::path source);
 
            asio::awaitable<std::optional<Transformation>> getNewestTransformation(const std::string& name) const;
 
            asio::awaitable<std::optional<Transformation>> getTransformation(const std::string& name, const evmc::address & address) const;
 
            asio::awaitable<bool> addCondition(evmc::address address, Condition condition, std::filesystem::path source);
 
            asio::awaitable<std::optional<Condition>> getNewestCondition(const std::string& name) const;
 
            asio::awaitable<std::optional<Condition>> getCondition(const std::string& name, const evmc::address & address) const;
 
            asio::awaitable<bool> checkIfSubFeaturesExist(const Feature & feature) const;
 
            asio::awaitable<absl::flat_hash_set<std::string>> getOwnedFeatures(const evmc::address & address) const;
            asio::awaitable<absl::flat_hash_set<std::string>> getOwnedTransformations(const evmc::address & address) const;
 
        protected:
 
            asio::awaitable<bool> containsFeatureBucket(const std::string& name) const;
 
            asio::awaitable<bool> containsTransformationBucket(const std::string& name) const;
 
            asio::awaitable<bool> containsConditionBucket(const std::string& name) const;
 
            asio::awaitable<bool> isFeatureBucketEmpty(const std::string& name) const;
 
            asio::awaitable<bool> isTransformationBucketEmpty(const std::string& name) const;
 
            asio::awaitable<bool> isConditionBucketEmpty(const std::string& name) const;
        
        protected:
            template<class T>
            struct Node
            {
                T value;
                std::filesystem::path path;
            };
 
        private:
            asio::strand<asio::io_context::executor_type> _strand;
 
            absl::flat_hash_map<std::string, evmc::address> _newest_feature;
            absl::flat_hash_map<std::string, evmc::address> _newest_transformation;
            absl::flat_hash_map<std::string, evmc::address> _newest_condition;
 
            absl::flat_hash_map<std::string, absl::flat_hash_map<evmc::address, FeatureRecord>> _features;
            absl::flat_hash_map<std::string, absl::flat_hash_map<evmc::address, TransformationRecord>> _transformations;
            absl::flat_hash_map<std::string, absl::flat_hash_map<evmc::address, Node<Condition>>> _conditions;
 
 
            absl::flat_hash_map<evmc::address, absl::flat_hash_set<std::string>> _owned_features;
            absl::flat_hash_map<evmc::address, absl::flat_hash_set<std::string>> _owned_transformations;
            absl::flat_hash_map<evmc::address, absl::flat_hash_set<std::string>> _owned_conditions;
    };
}