dependency_tracker.hpp

#pragma once
 
#include "data_kind.hpp"
#include "tagged_data.hpp"
 
#include <launchdarkly/data_model/descriptors.hpp>
#include <launchdarkly/data_model/flag.hpp>
#include <launchdarkly/data_model/rule_clause.hpp>
#include <launchdarkly/data_model/segment.hpp>
 
#include <array>
#include <set>
#include <string>
 
namespace launchdarkly::server_side::data_components {
 
class DependencySet {
   public:
    DependencySet();
    using DataType = std::array<TaggedData<std::set<std::string>>,
                                static_cast<std::size_t>(DataKind::kKindCount)>;
    void Set(DataKind kind, std::string key);
 
    void Remove(DataKind kind, std::string const& key);
 
    [[nodiscard]] bool Contains(DataKind kind, std::string const& key) const;
 
    [[nodiscard]] std::set<std::string> const& SetForKind(DataKind kind);
 
    [[nodiscard]] std::size_t Size() const;
 
    [[nodiscard]] typename DataType::const_iterator begin() const;
 
    [[nodiscard]] typename DataType::const_iterator end() const;
 
   private:
    [[nodiscard]] std::set<std::string> const& Data(DataKind kind) const;
 
    [[nodiscard]] std::set<std::string>& Data(DataKind kind);
 
    DataType data_;
};
 
class DependencyMap {
   public:
    DependencyMap();
    using DataType =
        std::array<TaggedData<std::unordered_map<std::string, DependencySet>>,
                   static_cast<std::size_t>(DataKind::kKindCount)>;
    void Set(DataKind kind, std::string key, DependencySet val);
 
    [[nodiscard]] std::optional<DependencySet> Get(
        DataKind kind,
        std::string const& key) const;
 
    void Clear();
 
    [[nodiscard]] typename DataType::const_iterator begin() const;
 
    [[nodiscard]] typename DataType::const_iterator end() const;
 
   private:
    DataType data_;
};
 
class DependencyTracker {
   public:
    void UpdateDependencies(std::string const& key,
                            data_model::FlagDescriptor const& flag);
 
    void UpdateDependencies(std::string const& key,
                            data_model::SegmentDescriptor const& segment);
 
    void CalculateChanges(DataKind kind,
                          std::string const& key,
                          DependencySet& dependency_set);
 
    void Clear();
 
   private:
    void UpdateDependencies(DataKind kind,
                            std::string const& key,
                            DependencySet const& deps);
 
    DependencyMap dependencies_from_;
    DependencyMap dependencies_to_;
 
    static void CalculateClauseDeps(
        DependencySet& dependencies,
        std::vector<data_model::Clause> const& clauses);
};
 
}  // namespace launchdarkly::server_side::data_components