json_property_set.h

#ifndef SOURCEMETA_CORE_JSON_PROPERTY_SET_H_
#define SOURCEMETA_CORE_JSON_PROPERTY_SET_H_
 
#ifndef SOURCEMETA_CORE_JSON_EXPORT
#include <sourcemeta/core/json_export.h>
#endif
 
#include <sourcemeta/core/json_hash.h>
#include <sourcemeta/core/json_value.h>
 
#include <cassert>  // assert
#include <optional> // std::optional
#include <utility>  // std::pair
#include <vector>   // std::vector
 
namespace sourcemeta::core {
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251 4275)
#endif

class SOURCEMETA_CORE_JSON_EXPORT JSONPropertySet {
public:
  JSONPropertySet() = default;

  using string_type = JSON::String;
  using hash_type = JSON::Object::hash_type;
  using value_type = std::pair<string_type, hash_type>;
  using underlying_type = std::vector<value_type>;
  using size_type = underlying_type::size_type;
  using difference_type = underlying_type::difference_type;
  using const_iterator = underlying_type::const_iterator;

  [[nodiscard]] auto contains(const string_type &value,
                              const hash_type hash) const -> bool {
    assert(HASHER(value) == hash);
    if (HASHER.is_perfect(hash)) {
      // A perfect hash captures the property name bytes but not its length, so
      // two names that differ only by trailing NUL bytes hash equal. Comparing
      // sizes disambiguates them without the cost of a full string comparison
      for (const auto &entry : this->data_) {
        if (entry.second == hash && entry.first.size() == value.size()) {
          return true;
        }
      }
    } else {
      for (const auto &entry : this->data_) {
        if (entry.second == hash && entry.first == value) {
          return true;
        }
      }
    }
 
    return false;
  }

  [[nodiscard]] auto contains(const string_type &value) const -> bool {
    return this->contains(value, HASHER(value));
  }

  auto insert(const string_type &value, const hash_type hash) -> bool;

  auto insert(string_type &&value, const hash_type hash) -> bool;

  auto insert(const string_type &value) -> bool;

  auto insert(string_type &&value) -> bool;

  [[nodiscard]] auto at(const size_type index) const noexcept
      -> const value_type & {
    assert(index < this->data_.size());
    return this->data_[index];
  }

  [[nodiscard]] auto empty() const noexcept -> bool {
    return this->data_.empty();
  }

  [[nodiscard]] auto size() const noexcept -> size_type {
    return this->data_.size();
  }

  [[nodiscard]] auto begin() const noexcept -> const_iterator {
    return this->data_.begin();
  }

  [[nodiscard]] auto end() const noexcept -> const_iterator {
    return this->data_.end();
  }

  [[nodiscard]] auto cbegin() const noexcept -> const_iterator {
    return this->data_.cbegin();
  }

  [[nodiscard]] auto cend() const noexcept -> const_iterator {
    return this->data_.cend();
  }

  [[nodiscard]] auto to_json() const -> JSON;

  static auto from_json(const JSON &value) -> std::optional<JSONPropertySet>;
 
private:
  static constexpr PropertyHashJSON<string_type> HASHER{};
  underlying_type data_;
};
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
 
} // namespace sourcemeta::core
 
#endif