attributes.hpp

#pragma once
 
#include <string>
#include <unordered_set>
 
#include <launchdarkly/attribute_reference.hpp>
#include <launchdarkly/value.hpp>
 
namespace launchdarkly {
 
class Attributes final {
   public:
    std::string const& Key() const;
 
    std::string const& Name() const;
 
    bool Anonymous() const;
 
    Value const& CustomAttributes() const;
 
    AttributeReference::SetType const& PrivateAttributes() const;
 
    launchdarkly::Value const& Get(
        launchdarkly::AttributeReference const& ref) const {
        if (!ref.Valid()) {
            // Cannot index by invalid references.
            return launchdarkly::Value::Null();
        }
        if (ref.IsKind()) {
            // Cannot access kind.
            return launchdarkly::Value::Null();
        }
 
        if (ref.Depth() == 1) {
            // Handle built-in attributes.
            if (ref.Component(0) == "key") {
                return key_;
            }
            if (ref.Component(0) == "name") {
                return name_;
            }
            if (ref.Component(0) == "anonymous") {
                return anonymous_;
            }
        }
 
        launchdarkly::Value const* node = &custom_attributes_;
        bool found = true;
        for (size_t index = 0; index < ref.Depth(); index++) {
            auto const& component = ref.Component(index);
            if (node->IsObject()) {
                auto const& map = node->AsObject();
                if (auto search = map.Find(component); search != map.end()) {
                    node = &search->second;
                } else {
                    found = false;
                    break;
                }
            } else {
                found = false;
            }
        }
        if (!found) {
            return launchdarkly::Value::Null();
        }
        return *node;
    }
 
    Attributes(std::string key,
               std::optional<std::string> name,
               bool anonymous,
               launchdarkly::Value attributes,
               AttributeReference::SetType private_attributes =
                   AttributeReference::SetType())
        : key_(std::move(key)),
          name_(std::move(name)),
          anonymous_(anonymous),
          private_attributes_(std::move(private_attributes)),
          custom_attributes_(std::move(attributes)) {}
 
    friend std::ostream& operator<<(std::ostream& out,
                                    Attributes const& attrs) {
        out << "{key: " << attrs.key_ << ", "
            << " name: " << attrs.name_ << " anonymous: " << attrs.anonymous_
            << " private: [";
        bool first = true;
        for (auto const& private_attribute : attrs.private_attributes_) {
            if (first) {
                first = false;
            } else {
                out << ", ";
            }
            out << private_attribute;
        }
        out << "] "
            << " custom: " << attrs.custom_attributes_ << "}";
 
        return out;
    }
 
    Attributes(Attributes const& context) = default;
 
    Attributes(Attributes&& context) = default;
 
    ~Attributes() = default;
 
    Attributes& operator=(Attributes const&) = default;
 
    Attributes& operator=(Attributes&&) = default;
 
   private:
    // Built-in attributes.
    launchdarkly::Value key_;
    launchdarkly::Value name_;
    launchdarkly::Value anonymous_;
    AttributeReference::SetType private_attributes_;
 
    launchdarkly::Value custom_attributes_;
 
    // Kinds are contained at the context level, not inside attributes.
};
 
}  // namespace launchdarkly