json-validator/include/jvalidate/adapter.h

#pragma once

#include <cstdint>
#include <map>
#include <optional>
#include <string_view>

#include <jvalidate/detail/array_iterator.h>
#include <jvalidate/detail/object_iterator.h>
#include <jvalidate/enum.h>
#include <jvalidate/forward.h>
#include <jvalidate/status.h>

namespace jvalidate::adapter {
class Adapter {
public:
  virtual ~Adapter() = default;

  virtual Type type() const = 0;
  virtual std::unique_ptr<Const const> freeze() const = 0;

  virtual bool as_boolean() const = 0;
  virtual int64_t as_integer() const = 0;
  virtual double as_number() const = 0;
  virtual std::string as_string() const = 0;

  virtual size_t array_size() const = 0;
  virtual size_t object_size() const = 0;

  virtual Status apply_array(AdapterCallback const & cb) const = 0;
  virtual Status apply_object(ObjectAdapterCallback const & cb) const = 0;

  virtual bool equals(Adapter const & lhs, bool strict) const = 0;

  bool maybe_null(bool strict) const {
    switch (type()) {
    case Type::Null:
      return true;
    case Type::String:
      return not strict and as_string().empty();
    default:
      return false;
    }
  }

  std::optional<bool> maybe_boolean(bool strict) const {
    switch (type()) {
    case Type::Boolean:
      return as_boolean();
    case Type::String:
      if (not strict) {
        auto str = as_string();
        if (str == "true") {
          return true;
        }
        if (str == "false") {
          return false;
        }
      }
      return std::nullopt;
    default:
      return std::nullopt;
    }
  }

  std::optional<int64_t> maybe_integer(bool strict) const {
    switch (type()) {
    case Type::Integer:
      return as_integer();
    case Type::Number: {
      double number = as_number();
      int64_t integer = static_cast<int64_t>(number);
      return static_cast<double>(integer) == number ? std::make_optional(integer) : std::nullopt;
    }
    case Type::Boolean:
      if (not strict) {
        return as_boolean() ? 1 : 0;
      }
      return std::nullopt;
    case Type::String:
      if (not strict) {
        auto str = as_string();
        size_t end = 0;
        int64_t rval = std::stoll(str, &end);
        if (end == str.size()) {
          return rval;
        }
      }
      return std::nullopt;
    default:
      return std::nullopt;
    }
  }

  std::optional<double> maybe_number(bool strict) const {
    switch (type()) {
    case Type::Number:
      return as_number();
    case Type::Integer:
      return as_integer();
    case Type::String:
      if (not strict) {
        auto str = as_string();
        size_t end = 0;
        double rval = std::stod(str, &end);
        if (end == str.size()) {
          return rval;
        }
      }
      return std::nullopt;
    default:
      return std::nullopt;
    }
  }

  std::optional<std::string> maybe_string(bool strict) const {
    switch (type()) {
    case Type::Null:
      return strict ? std::nullopt : std::make_optional("");
    case Type::String:
      return as_string();
    case Type::Number:
      if (not strict) {
        return std::to_string(as_number());
      }
      return std::nullopt;
    case Type::Integer:
      if (not strict) {
        return std::to_string(as_integer());
      }
      return std::nullopt;
    case Type::Boolean:
      if (not strict) {
        return as_boolean() ? "true" : "false";
      }
      return std::nullopt;
    default:
      return std::nullopt;
    }
  }
};

class Const {
public:
  virtual ~Const() = default;
  virtual Status apply(AdapterCallback const & cb) const = 0;
};
}

namespace jvalidate::adapter::detail {
template <typename JSON> class GenericConst final : public Const {
public:
  explicit GenericConst(JSON const & value) : value_(value) {}

  Status apply(AdapterCallback const & cb) const {
    return cb(typename AdapterTraits<JSON>::ConstAdapter(value_));
  }

  JSON const & value() const { return value_; }

private:
  JSON value_;
};
}