json_hash.h

#ifndef SOURCEMETA_CORE_JSON_HASH_H_
#define SOURCEMETA_CORE_JSON_HASH_H_
 
#include <sourcemeta/core/numeric.h>
 
#include <bit>        // std::endian
#include <cassert>    // assert
#include <cstddef>    // std::size_t
#include <cstring>    // std::memcpy
#include <functional> // std::reference_wrapper
 
namespace sourcemeta::core {

template <typename T> struct HashJSON {
  using hash_type = std::uint64_t;
 
  inline auto operator()(const T &value) const noexcept -> hash_type {
    if constexpr (requires { value.get().fast_hash(); }) {
      return value.get().fast_hash();
    } else {
      return value.fast_hash();
    }
  }

  [[nodiscard]]
  inline auto is_perfect(const hash_type) const noexcept -> bool {
    return false;
  }
};

template <typename T> struct PropertyHashJSON {
  struct hash_type {
    using type = sourcemeta::core::uint128_t;
    type a{0};
    type b{0};
 
    auto operator==(const hash_type &) const noexcept -> bool = default;
  };

  [[nodiscard]]
  constexpr auto perfect(const char *data,
                         const std::size_t size) const noexcept -> hash_type {
    hash_type result;
    assert(size > 0);
    if consteval {
      // A constant evaluation cannot memcpy through a reinterpret_cast, so pack
      // the bytes arithmetically instead. This reproduces the runtime memcpy on
      // a little-endian target, where the packed bytes read back as the same
      // integer, which the static assertion enforces so the two can never
      // silently diverge
      static_assert(std::endian::native == std::endian::little);
      for (std::size_t index = 0; index < size; index += 1) {
        const auto byte{static_cast<typename hash_type::type>(
            static_cast<unsigned char>(data[index]))};
        const auto position{index + 1};
        if (position < 16) {
          result.a |= byte << static_cast<int>(8 * position);
        } else {
          result.b |= byte << static_cast<int>(8 * (position - 16));
        }
      }
    } else {
      std::memcpy(reinterpret_cast<char *>(&result) + 1, data, size);
    }
 
    return result;
  }
 
  // GCC does not optimise well across implicit type conversions such as
  // std::string to std::string_view, so we provide separate overloads with
  // duplicated logic instead of unifying on a single parameter type
 
  constexpr auto operator()(const T &value) const noexcept -> hash_type {
    const auto size{value.size()};
    switch (size) {
      case 0:
        return {};
      case 1:
        return this->perfect(value.data(), 1);
      case 2:
        return this->perfect(value.data(), 2);
      case 3:
        return this->perfect(value.data(), 3);
      case 4:
        return this->perfect(value.data(), 4);
      case 5:
        return this->perfect(value.data(), 5);
      case 6:
        return this->perfect(value.data(), 6);
      case 7:
        return this->perfect(value.data(), 7);
      case 8:
        return this->perfect(value.data(), 8);
      case 9:
        return this->perfect(value.data(), 9);
      case 10:
        return this->perfect(value.data(), 10);
      case 11:
        return this->perfect(value.data(), 11);
      case 12:
        return this->perfect(value.data(), 12);
      case 13:
        return this->perfect(value.data(), 13);
      case 14:
        return this->perfect(value.data(), 14);
      case 15:
        return this->perfect(value.data(), 15);
      case 16:
        return this->perfect(value.data(), 16);
      case 17:
        return this->perfect(value.data(), 17);
      case 18:
        return this->perfect(value.data(), 18);
      case 19:
        return this->perfect(value.data(), 19);
      case 20:
        return this->perfect(value.data(), 20);
      case 21:
        return this->perfect(value.data(), 21);
      case 22:
        return this->perfect(value.data(), 22);
      case 23:
        return this->perfect(value.data(), 23);
      case 24:
        return this->perfect(value.data(), 24);
      case 25:
        return this->perfect(value.data(), 25);
      case 26:
        return this->perfect(value.data(), 26);
      case 27:
        return this->perfect(value.data(), 27);
      case 28:
        return this->perfect(value.data(), 28);
      case 29:
        return this->perfect(value.data(), 29);
      case 30:
        return this->perfect(value.data(), 30);
      case 31:
        return this->perfect(value.data(), 31);
      default:
        // This case is specifically designed to be constant with regards to
        // string length, and to exploit the fact that most JSON objects don't
        // have a lot of entries, so hash collision is not as common
        auto hash = this->perfect(value.data(), 31);
        hash.a |= 1 + (static_cast<std::uint64_t>(size) +
                       static_cast<typename hash_type::type>(value.front()) +
                       static_cast<typename hash_type::type>(value.back())) %
                          // Make sure the property hash can never exceed 8 bits
                          255;
        return hash;
    }
  }
 
  constexpr auto operator()(const char *data,
                            const std::size_t size) const noexcept
      -> hash_type {
    switch (size) {
      case 0:
        return {};
      case 1:
        return this->perfect(data, 1);
      case 2:
        return this->perfect(data, 2);
      case 3:
        return this->perfect(data, 3);
      case 4:
        return this->perfect(data, 4);
      case 5:
        return this->perfect(data, 5);
      case 6:
        return this->perfect(data, 6);
      case 7:
        return this->perfect(data, 7);
      case 8:
        return this->perfect(data, 8);
      case 9:
        return this->perfect(data, 9);
      case 10:
        return this->perfect(data, 10);
      case 11:
        return this->perfect(data, 11);
      case 12:
        return this->perfect(data, 12);
      case 13:
        return this->perfect(data, 13);
      case 14:
        return this->perfect(data, 14);
      case 15:
        return this->perfect(data, 15);
      case 16:
        return this->perfect(data, 16);
      case 17:
        return this->perfect(data, 17);
      case 18:
        return this->perfect(data, 18);
      case 19:
        return this->perfect(data, 19);
      case 20:
        return this->perfect(data, 20);
      case 21:
        return this->perfect(data, 21);
      case 22:
        return this->perfect(data, 22);
      case 23:
        return this->perfect(data, 23);
      case 24:
        return this->perfect(data, 24);
      case 25:
        return this->perfect(data, 25);
      case 26:
        return this->perfect(data, 26);
      case 27:
        return this->perfect(data, 27);
      case 28:
        return this->perfect(data, 28);
      case 29:
        return this->perfect(data, 29);
      case 30:
        return this->perfect(data, 30);
      case 31:
        return this->perfect(data, 31);
      default:
        // This case is specifically designed to be constant with regards to
        // string length, and to exploit the fact that most JSON objects don't
        // have a lot of entries, so hash collision is not as common
        auto hash = this->perfect(data, 31);
        hash.a |= 1 + (static_cast<std::uint64_t>(size) +
                       static_cast<typename hash_type::type>(data[0]) +
                       static_cast<typename hash_type::type>(data[size - 1])) %
                          // Make sure the property hash can never exceed 8 bits
                          255;
        return hash;
    }
  }

  [[nodiscard]]
  constexpr auto is_perfect(const hash_type &hash) const noexcept -> bool {
    // If there is anything written past the first byte,
    // then it is a perfect hash
    return (hash.a & 255) == 0;
  }
};

template <typename T> struct EqualJSON {
  inline auto operator()(const T &left, const T &right) const -> bool {
    if constexpr (requires { left.get() == right.get(); }) {
      return left.get() == right.get();
    } else {
      return left == right;
    }
  }
};
 
} // namespace sourcemeta::core
 
#endif