jsonpointer_token.h

#ifndef SOURCEMETA_CORE_JSONPOINTER_TOKEN_H_
#define SOURCEMETA_CORE_JSONPOINTER_TOKEN_H_
 
#include <sourcemeta/core/json.h>
 
#include <cassert> // assert
 
namespace sourcemeta::core {

template <typename PropertyT, typename Hash> class GenericToken {
public:
  using Value = JSON;
  using Property = PropertyT;
  using Index = typename Value::Array::size_type;

  GenericToken(Property value, const typename Hash::hash_type property_hash)
      : as_property{true}, property{std::move(value)}, hash{property_hash},
        index{0} {}

  GenericToken(const Property &value) : GenericToken{value, hasher(value)} {}

  GenericToken(Property &&value)
      : as_property{true}, property{std::move(value)}, hash{hasher(property)},
        index{0} {}

  GenericToken(const JSON::Char *const value)
      : GenericToken{value, hasher(value)} {}

  GenericToken(const JSON::Char value)
      : GenericToken{Property{value}, hasher(Property{value})} {}

  GenericToken(const Index value)
      : as_property{false}, property{DEFAULT_PROPERTY}, hash{0}, index{value} {}

  GenericToken(const int value)
      : as_property{false}, property{DEFAULT_PROPERTY}, hash{0},
        index{static_cast<Index>(value)} {
    assert(value >= 0);
  }
 
#if defined(_MSC_VER)
  GenericToken(const unsigned long value)
      : as_property{false}, property{DEFAULT_PROPERTY}, hash{0}, index{value} {}
#endif

  [[nodiscard]] auto is_property() const noexcept -> bool {
    return this->as_property;
  }

  [[nodiscard]] auto is_hyphen() const noexcept -> bool {
    return this->as_property && this->property.size() == 1 &&
           this->property.front() == '\u002D';
  }

  [[nodiscard]] auto is_index() const noexcept -> bool {
    return !this->as_property;
  }

  [[nodiscard]] auto to_property() const noexcept -> const auto & {
    assert(this->is_property());
    if constexpr (requires { this->property.get(); }) {
      return this->property.get();
    } else {
      return this->property;
    }
  }

  [[nodiscard]] auto property_hash() const noexcept ->
      typename Hash::hash_type {
    assert(this->is_property());
    return this->hash;
  }

  [[nodiscard]] auto
  property_equals(const JSON::StringView value,
                  const typename Hash::hash_type value_hash) const noexcept
      -> bool {
    assert(this->is_property());
    assert(hasher(value.data(), value.size()) == value_hash);
    if constexpr (requires { hasher.is_perfect(value_hash); }) {
      // A perfect hash captures the property bytes but not its length, so
      // two properties that differ only by trailing NUL bytes hash equal.
      // Comparing sizes disambiguates them without the cost of a full
      // string comparison
      return this->hash == value_hash &&
             (hasher.is_perfect(value_hash)
                  ? this->to_property().size() == value.size()
                  : this->to_property() == value);
    } else {
      return this->hash == value_hash && this->to_property() == value;
    }
  }

  auto to_property() noexcept -> auto & {
    assert(this->is_property());
    if constexpr (requires { this->property.get(); }) {
      return this->property.get();
    } else {
      return this->property;
    }
  }

  [[nodiscard]] auto to_index() const noexcept -> Index {
    assert(this->is_index());
    return this->index;
  }

  [[nodiscard]] auto to_json() const -> JSON {
    if (this->is_property()) {
      return JSON{this->to_property()};
    } else {
      return JSON{this->to_index()};
    }
  }

  auto operator==(const GenericToken<PropertyT, Hash> &other) const noexcept
      -> bool {
    if (this->as_property != other.as_property) {
      return false;
    } else if (this->as_property) {
      if constexpr (requires { hasher.is_perfect(this->hash); }) {
        // A perfect hash captures the property bytes but not its length, so
        // two properties that differ only by trailing NUL bytes hash equal.
        // Comparing sizes disambiguates them without the cost of a full
        // string comparison
        if (hasher.is_perfect(this->hash) && hasher.is_perfect(other.hash)) {
          return this->hash == other.hash &&
                 this->to_property().size() == other.to_property().size();
        }
      }
 
      return this->hash == other.hash &&
             this->to_property() == other.to_property();
    } else {
      return this->index == other.index;
    }
  }

  auto operator<(const GenericToken<PropertyT, Hash> &other) const noexcept
      -> bool {
    if (this->as_property && !other.as_property) {
      return true;
    } else if (!this->as_property && other.as_property) {
      return false;
    } else if (this->as_property) {
      return this->to_property() < other.to_property();
    } else {
      return this->index < other.index;
    }
  }
 
private:
  // We need this as a member for making WeakPointer work
  inline static const Value::String DEFAULT_PROPERTY{};
  inline static const Hash hasher;
 
  bool as_property;
  Property property;
  typename Hash::hash_type hash;
  Index index;
};
 
} // namespace sourcemeta::core
 
#endif