attributes_builder.hpp

#pragma once
 
#include <launchdarkly/attribute_reference.hpp>
#include <launchdarkly/attributes.hpp>
#include <launchdarkly/value.hpp>
 
#include <map>
#include <string>
 
namespace launchdarkly {
class ContextBuilder;
 
template <class BuilderReturn, class BuildType>
class AttributesBuilder final {
    friend class ContextBuilder;
 
public:
    AttributesBuilder(BuilderReturn& builder, std::string kind, std::string key)
        : builder_(builder), kind_(std::move(kind)), key_(std::move(key)) {
    }
 
    AttributesBuilder(BuilderReturn& builder,
                      std::string kind,
                      Attributes const& attributes)
        : builder_(builder),
          kind_(std::move(kind)),
          key_(attributes.Key()),
          name_(attributes.Name()),
          anonymous_(attributes.Anonymous()),
          private_attributes_(attributes.PrivateAttributes()) {
        for (auto& pair : attributes.CustomAttributes().AsObject()) {
            values_[pair.first] = pair.second;
        }
    }
 
    AttributesBuilder(AttributesBuilder const& builder) = delete;
    AttributesBuilder& operator=(AttributesBuilder const&) = delete;
    AttributesBuilder& operator=(AttributesBuilder&&) = delete;
 
    // This cannot be noexcept because of:
    // https://developercommunity.visualstudio.com/t/bug-in-stdmapstdpair-implementation-with-move-only/840554
    AttributesBuilder(AttributesBuilder&& builder) = default;
    ~AttributesBuilder() = default;
 
    AttributesBuilder& Name(std::string name);
 
    AttributesBuilder& Anonymous(bool anonymous);
 
    AttributesBuilder& Set(std::string name, Value value);
 
    AttributesBuilder& SetPrivate(std::string name, Value value);
 
    AttributesBuilder& AddPrivateAttribute(AttributeReference ref);
 
    template <typename IterType>
    AttributesBuilder& AddPrivateAttributes(IterType attributes) {
        for (auto iter : attributes) {
            private_attributes_.insert(iter);
        }
        return *this;
    }
 
    AttributesBuilder& Kind(std::string kind, std::string key) {
        return builder_.Kind(kind, key);
    }
 
    AttributesBuilder* Kind(std::string const& kind) {
        return builder_.Kind(kind);
    }
 
    [[nodiscard]] BuildType Build() const { return builder_.Build(); }
 
private:
    BuilderReturn& builder_;
 
    void Key(std::string key) { key_ = std::move(key); }
 
    Attributes BuildAttributes() const;
 
    AttributesBuilder& Set(std::string name,
                           Value value,
                           bool private_attribute);
 
 
    std::string kind_;
    std::string key_;
    std::string name_;
    bool anonymous_ = false;
 
    std::map<std::string, Value> values_;
    AttributeReference::SetType private_attributes_;
};
} // namespace launchdarkly