atom.hpp

#ifndef HALCHECK_LIB_ATOM_HPP
#define HALCHECK_LIB_ATOM_HPP
 
#include <halcheck/lib/type_traits.hpp>
#include <halcheck/lib/variant.hpp>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <string>
#include <type_traits>
#include <utility>
 
namespace halcheck { namespace lib {
 
class symbol {
public:
  using value_type = std::string;
 
  explicit symbol(const std::string &);
 
  explicit symbol(const char * = "");
 
  inline std::size_t hash() const noexcept { return _data->second; }
 
  template<typename T, HALCHECK_REQUIRE(std::is_constructible<T, const std::string &>())>
  explicit operator T() const {
    return T(_data->first);
  }
 
private:
  friend bool operator==(const symbol &lhs, const symbol &rhs) { return lhs._data == rhs._data; }
 
  friend bool operator!=(const symbol &lhs, const symbol &rhs) { return lhs._data != rhs._data; }
 
  std::pair<const std::string, std::size_t> *_data;
};
 
class number {
public:
  using value_type = std::int64_t;
 
  number() = default;
 
  number(value_type value) // NOLINT: implicit conversion
      : _value(value) {}
 
  template<
      typename T,
      HALCHECK_REQUIRE(std::is_integral<T>()),
      HALCHECK_REQUIRE(std::is_signed<T>()),
      HALCHECK_REQUIRE(sizeof(T) >= sizeof(value_type))>
  explicit operator T() const {
    return _value;
  }
 
  template<
      typename T,
      HALCHECK_REQUIRE(!std::is_integral<T>()),
      HALCHECK_REQUIRE(std::is_constructible<T, const value_type &>())>
  explicit operator T() const {
    return T(_value);
  }
 
private:
  friend bool operator==(number lhs, number rhs) { return lhs._value == rhs._value; }
 
  friend bool operator!=(number lhs, number rhs) { return lhs._value != rhs._value; }
 
  value_type _value = 0;
};
 
using atom = lib::variant<lib::symbol, lib::number>;
 
namespace literals {
#if __cplusplus >= 201806L
template<std::size_t N>
struct char_array {
  char data[N]; // NOLINT
  [[nodiscard]] constexpr size_t size() const { return N - 1; }
  constexpr char_array(const char (&init)[N]) { // NOLINT
    std::copy_n(init, N, data);
  }
};
 
template<literals::char_array Value>
lib::symbol operator""_s() {
  static lib::symbol output(std::string(Value.data, Value.size()));
  return output;
}
#elif ((__cplusplus >= 201606L || defined(__clang__)) && defined(__GNUG__)) || defined(HALCHECK_DOXYGEN)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
template<typename T, T... Data>
lib::symbol operator""_s() {
  static_assert(std::is_same<T, char>(), "T should be char");
  static lib::symbol output(std::string{Data...});
  return output;
}
#pragma clang diagnostic pop
#else
inline lib::symbol operator""_s(const char *data, std::size_t size) { return lib::symbol(std::string(data, size)); }
#endif
} // namespace literals
 
}} // namespace halcheck::lib
 
namespace std {
 
template<>
struct hash<halcheck::lib::symbol> {
  std::size_t operator()(halcheck::lib::symbol value) const noexcept { return value.hash(); }
};
 
template<>
struct hash<halcheck::lib::number> {
  std::size_t operator()(halcheck::lib::number value) const noexcept {
    return std::hash<halcheck::lib::number::value_type>()(halcheck::lib::number::value_type(value));
  }
};
 
} // namespace std
#endif