evaluation_stack.hpp

#pragma once
 
#include <launchdarkly/data/evaluation_reason.hpp>
#include <launchdarkly/server_side/integrations/big_segments/big_segment_store_types.hpp>
 
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
namespace launchdarkly::server_side::data_components {
class BigSegmentStoreWrapper;
}  // namespace launchdarkly::server_side::data_components
 
namespace launchdarkly::server_side::evaluation {
 
struct Guard {
    Guard(std::unordered_set<std::string>& set, std::string key);
    ~Guard();
 
    Guard(Guard const&) = delete;
    Guard& operator=(Guard const&) = delete;
 
    Guard(Guard&&) = delete;
    Guard& operator=(Guard&&) = delete;
 
   private:
    std::unordered_set<std::string>& set_;
    std::string const key_;
};
 
class EvaluationStack {
   public:
    explicit EvaluationStack(
        data_components::BigSegmentStoreWrapper* big_segment_store = nullptr);
 
    [[nodiscard]] std::optional<Guard> NoticePrerequisite(
        std::string prerequisite_key);
 
    [[nodiscard]] std::optional<Guard> NoticeSegment(std::string segment_key);
 
    [[nodiscard]] data_components::BigSegmentStoreWrapper* BigSegmentStore()
        const;
 
    void RecordBigSegmentsStatus(enum EvaluationReason::BigSegmentsStatus status);
 
    [[nodiscard]] enum EvaluationReason::BigSegmentsStatus BigSegmentsStatus()
        const;
 
    [[nodiscard]] integrations::Membership const* FindMembership(
        std::string const& context_key) const;
 
    void StoreMembership(std::string context_key,
                         integrations::Membership membership);
 
    void RecordStoreError(std::string context_key);
 
    [[nodiscard]] bool DidStoreError(std::string const& context_key) const;
 
   private:
    std::unordered_set<std::string> prerequisites_seen_;
    std::unordered_set<std::string> segments_seen_;
 
    data_components::BigSegmentStoreWrapper* big_segment_store_;
    enum EvaluationReason::BigSegmentsStatus big_segments_status_ =
        EvaluationReason::BigSegmentsStatus::kNone;
    // Keyed by unhashed context key. Empty until the first Big Segment lookup.
    std::unordered_map<std::string, integrations::Membership> memberships_;
    std::unordered_set<std::string> store_error_keys_;
};
 
}  // namespace launchdarkly::server_side::evaluation