context.hpp

#pragma once
 
#include <string>
#include <vector>
 
#include <launchdarkly/attributes.hpp>
#include <launchdarkly/value.hpp>
 
namespace launchdarkly {
 
struct ContextErrors {
    inline static const std::string kInvalidKind =
        "\"Kind contained invalid characters. A kind may contain ASCII letters "
        "or "
        "numbers, as well as '.', '-', and '_'.\"";
    // For now disallow an empty key. This may need changed if anonymous key
    // generation and persistence is added.
    inline static const std::string kInvalidKey =
        "\"The key for a context may not be empty.\"";
    inline static const std::string kMissingKinds =
        "\"The context must contain at least 1 kind.\"";
};
 
class ContextBuilder;
 
class Context final {
    friend class ContextBuilder;
 
   public:
    [[nodiscard]] std::vector<std::string> const& Kinds() const;
 
    [[nodiscard]] launchdarkly::Attributes const& Attributes(
        std::string const& kind) const;
 
    [[nodiscard]] Value const& Get(
        std::string const& kind,
        launchdarkly::AttributeReference const& ref) const;
 
    [[nodiscard]] bool Valid() const { return valid_; }
 
    [[nodiscard]] std::string const& CanonicalKey() const;
 
    [[nodiscard]] std::map<std::string, std::string> const& KindsToKeys() const;
 
    std::string const& errors() { return errors_; }
 
    friend std::ostream& operator<<(std::ostream& out, Context const& context) {
        if (context.valid_) {
            out << "{contexts: [";
            bool first = true;
            for (auto const& kind : context.attributes_) {
                if (first) {
                    first = false;
                } else {
                    out << ", ";
                }
                out << "kind: " << kind.first << " attributes: " << kind.second;
            }
            out << "]";
        } else {
            out << "{invalid: errors: [" << context.errors_ << "]";
        }
 
        return out;
    }
 
    ~Context() = default;
    Context(Context const& context) = default;
    Context(Context&& context) = default;
    Context& operator=(Context const&) = default;
    Context& operator=(Context&&) = default;
 
   private:
    Context(std::string error_message);
 
    Context(std::map<std::string, launchdarkly::Attributes> attributes);
 
    std::map<std::string, launchdarkly::Attributes> attributes_;
    std::vector<std::string> kinds_;
    std::map<std::string, std::string> kinds_to_keys_;
    bool valid_ = false;
    std::string errors_;
    std::string canonical_key_;
 
    std::string make_canonical_key();
};
 
}  // namespace launchdarkly