all_flags_state.hpp

#pragma once
 
#include <launchdarkly/data/evaluation_reason.hpp>
#include <launchdarkly/value.hpp>
 
#include <cstdint>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace launchdarkly::server_side {
 
class AllFlagsState {
   public:
    enum class Options : std::uint8_t {
        Default = 0,
        IncludeReasons = (1 << 0),
        DetailsOnlyForTrackedFlags = (1 << 1),
        ClientSideOnly = (1 << 2)
    };
 
    class State {
       public:
        State(std::uint64_t version,
              std::optional<std::int64_t> variation,
              std::optional<EvaluationReason> reason,
              bool track_events,
              bool track_reason,
              std::optional<std::uint64_t> debug_events_until_date);
 
        State(std::uint64_t version,
              std::optional<std::int64_t> variation,
              std::optional<EvaluationReason> reason,
              bool track_events,
              bool track_reason,
              std::optional<std::uint64_t> debug_events_until_date,
              std::vector<std::string> prerequisites);
 
        [[nodiscard]] std::uint64_t Version() const;
 
        [[nodiscard]] std::optional<std::int64_t> Variation() const;
 
        [[nodiscard]] std::optional<EvaluationReason> const& Reason() const;
 
        [[nodiscard]] bool TrackEvents() const;
 
        [[nodiscard]] bool TrackReason() const;
 
        [[nodiscard]] std::optional<std::uint64_t> const& DebugEventsUntilDate()
            const;
 
        [[nodiscard]] bool OmitDetails() const;
 
        [[nodiscard]] std::vector<std::string> const& Prerequisites() const;
 
        friend class AllFlagsStateBuilder;
 
       private:
        std::uint64_t version_;
        std::optional<std::int64_t> variation_;
        std::optional<EvaluationReason> reason_;
        bool track_events_;
        bool track_reason_;
        std::optional<std::uint64_t> debug_events_until_date_;
        bool omit_details_;
        std::vector<std::string> prerequisites_;
    };
 
    [[nodiscard]] bool Valid() const;
 
    [[nodiscard]] std::unordered_map<std::string, State> const& States() const;
 
    [[nodiscard]] std::unordered_map<std::string, Value> const& Values() const;
 
    AllFlagsState();
 
    AllFlagsState(std::unordered_map<std::string, Value> evaluations,
                  std::unordered_map<std::string, class State> flags_state);
 
   private:
    bool const valid_;
    std::unordered_map<std::string, class State> const flags_state_;
    std::unordered_map<std::string, Value> const evaluations_;
};
 
void operator|=(AllFlagsState::Options& lhs, AllFlagsState::Options rhs);
AllFlagsState::Options operator|(AllFlagsState::Options lhs,
                                 AllFlagsState::Options rhs);
 
AllFlagsState::Options operator&(AllFlagsState::Options lhs,
                                 AllFlagsState::Options rhs);
 
bool operator==(class AllFlagsState::State const& lhs,
                class AllFlagsState::State const& rhs);
 
bool operator==(AllFlagsState const& lhs, AllFlagsState const& rhs);
 
}  // namespace launchdarkly::server_side