evaluation_reason.hpp

#pragma once
 
#include <cstddef>
#include <optional>
#include <ostream>
#include <string>
 
namespace launchdarkly {
 
class EvaluationReason {
   public:
    enum class Kind {
        // The flag was off and therefore returned its configured off value.
        kOff = 0,
        // The flag was on but the context did not match any targets or rules.
        kFallthrough = 1,
        // The context key was specifically targeted for this flag.
        kTargetMatch = 2,
        // The context matched one of the flag's rules.
        kRuleMatch = 3,
        // The flag was considered off because it had at least one prerequisite
        // flag that either was off or did not return the desired variation.
        kPrerequisiteFailed = 4,
        // The flag could not be evaluated, e.g. because it does not exist or
        // due to an unexpected error.
        kError = 5
    };
    friend std::ostream& operator<<(std::ostream& out, Kind const& kind);
 
    enum class ErrorKind {
        // The SDK was not yet fully initialized and cannot evaluate flags.
        kClientNotReady = 0,
        // The application did not pass valid context attributes to the SDK
        // evaluation method.
        kUserNotSpecified = 1,
        // No flag existed with the specified flag key.
        kFlagNotFound = 2,
        // The application requested an evaluation result of one type but the
        // resulting flag variation value was of a different type.
        kWrongType = 3,
        // The flag had invalid properties.
        kMalformedFlag = 4,
        // An unexpected error happened that stopped evaluation.
        kException = 5,
    };
 
    friend std::ostream& operator<<(std::ostream& out, ErrorKind const& kind);
 
    [[nodiscard]] enum Kind const& Kind() const;
 
    [[nodiscard]] std::optional<ErrorKind> ErrorKind() const;
 
    [[nodiscard]] std::optional<std::size_t> RuleIndex() const;
 
    [[nodiscard]] std::optional<std::string> RuleId() const;
 
    [[nodiscard]] std::optional<std::string> PrerequisiteKey() const;
 
    [[nodiscard]] bool InExperiment() const;
 
    [[nodiscard]] std::optional<std::string> BigSegmentStatus() const;
 
    EvaluationReason(enum Kind kind,
                     std::optional<enum ErrorKind> error_kind,
                     std::optional<std::size_t> rule_index,
                     std::optional<std::string> rule_id,
                     std::optional<std::string> prerequisite_key,
                     bool in_experiment,
                     std::optional<std::string> big_segment_status);
 
    explicit EvaluationReason(enum ErrorKind error_kind);
 
    static EvaluationReason Off();
 
    static EvaluationReason PrerequisiteFailed(std::string prerequisite_key);
 
    static EvaluationReason TargetMatch();
 
    static EvaluationReason Fallthrough(bool in_experiment);
 
    static EvaluationReason RuleMatch(std::size_t rule_index,
                                      std::optional<std::string> rule_id,
                                      bool in_experiment);
 
    static EvaluationReason MalformedFlag();
 
    friend std::ostream& operator<<(std::ostream& out,
                                    EvaluationReason const& reason);
 
   private:
    enum Kind kind_;
    std::optional<enum ErrorKind> error_kind_;
    std::optional<std::size_t> rule_index_;
    std::optional<std::string> rule_id_;
    std::optional<std::string> prerequisite_key_;
    bool in_experiment_;
    std::optional<std::string> big_segment_status_;
};
 
bool operator==(EvaluationReason const& lhs, EvaluationReason const& rhs);
bool operator!=(EvaluationReason const& lhs, EvaluationReason const& rhs);
 
}  // namespace launchdarkly