attribute_reference.hpp

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <ostream>
#include <set>
#include <string>
#include <vector>
 
namespace launchdarkly {
 
class AttributeReference {
   public:
    using SetType = std::set<AttributeReference>;
 
    [[nodiscard]] std::string const& Component(std::size_t depth) const;
 
    [[nodiscard]] std::size_t Depth() const;
 
    [[nodiscard]] bool IsKind() const;
 
    [[nodiscard]] bool Valid() const;
 
    [[nodiscard]] std::string const& RedactionName() const;
 
    static AttributeReference FromReferenceStr(std::string ref_str);
 
    static AttributeReference FromLiteralStr(std::string lit_str);
 
    static std::string PathToStringReference(
        std::vector<std::string_view> path);
 
    friend std::ostream& operator<<(std::ostream& os,
                                    AttributeReference const& ref) {
        os << (ref.Valid() ? "valid" : "invalid") << "(" << ref.RedactionName()
           << ")";
        return os;
    }
 
    AttributeReference(std::string ref_str);
 
    AttributeReference(char const* ref_str);
 
    AttributeReference();
 
    bool operator==(AttributeReference const& other) const {
        return components_ == other.components_;
    }
 
    bool operator==(std::vector<std::string_view> const& path) const {
        return components_.size() == path.size() &&
               std::equal(components_.begin(), components_.end(), path.begin());
    }
 
    bool operator!=(AttributeReference const& other) const {
        return !(*this == other);
    }
 
    bool operator!=(std::vector<std::string_view> const& path) const {
        return !(*this == path);
    }
 
    bool operator<(AttributeReference const& rhs) const {
        return components_ < rhs.components_;
    }
 
   private:
    AttributeReference(std::string str, bool is_literal);
 
    bool valid_ = false;
 
    std::string redaction_name_;
    std::vector<std::string> components_;
    inline static const std::string empty_;
};
 
}  // namespace launchdarkly