brace.h

#ifndef __BRACE_JSON_H__
#define __BRACE_JSON_H__
 
#include <cassert>
#include <sstream>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
 
#include "../priv/brace/tokenizer.h"
#include "result.h"
 
namespace brace {
 
class JsonValue;
 
struct JsonNullValue {};
 
using JsonObject = std::unordered_map<std::string, JsonValue>;
using JsonArray = std::vector<JsonValue>;
 
class JsonValue {
  public:
    using Value = std::variant<
        bool,
        double,
        std::string,
        JsonObject,
        JsonArray,
        JsonNullValue>;
 
    JsonValue() : m_value(JsonNullValue {}) {}
 
    JsonValue(bool b) : m_value(b) {}
 
    JsonValue(double d) : m_value(d) {}
 
    JsonValue(const std::string& s) : m_value(s) {}
 
    JsonValue(const JsonObject& obj) : m_value(obj) {}
 
    JsonValue(const JsonArray& arr) : m_value(arr) {}
 
    inline bool is_null() const {
        return std::holds_alternative<JsonNullValue>(m_value);
    }
 
    inline bool is_bool() const {
        return std::holds_alternative<bool>(m_value);
    }
 
    inline bool is_number() const {
        return std::holds_alternative<double>(m_value);
    }
 
    inline bool is_string() const {
        return std::holds_alternative<std::string>(m_value);
    }
 
    inline bool is_object() const {
        return std::holds_alternative<JsonObject>(m_value);
    }
 
    inline bool is_array() const {
        return std::holds_alternative<JsonArray>(m_value);
    }
 
    inline const Value& value() const {
        return m_value;
    }
 
    inline operator std::string() const {
        assert(is_string() && "JsonValue is not a string");
        return std::get<std::string>(m_value);
    }
 
    inline operator int() const {
        assert(is_number() && "JsonValue is not a number");
        return static_cast<int>(std::get<double>(m_value));
    }
 
    inline operator double() const {
        assert(is_number() && "JsonValue is not a number");
        return std::get<double>(m_value);
    }
 
    inline operator float() const {
        assert(is_number() && "JsonValue is not a number");
        return static_cast<float>(std::get<double>(m_value));
    }
 
    inline operator size_t() const {
        assert(is_number() && "JsonValue is not a number");
        return static_cast<size_t>(std::get<double>(m_value));
    }
 
    inline operator bool() const {
        assert(is_bool() && "JsonValue is not a bool");
        return std::get<bool>(m_value);
    }
 
    inline const JsonArray& to_array() const {
        assert(is_array() && "JsonValue is not an array");
        return std::get<JsonArray>(m_value);
    }
 
    inline bool operator==(const std::string& other) const {
        if (std::holds_alternative<std::string>(m_value)) {
            return std::get<std::string>(m_value) == other;
        }
        return false;
    }
 
    inline bool operator==(const char* other) const {
        return *this == std::string(other);
    }
 
    inline bool operator==(double other) const {
        if (std::holds_alternative<double>(m_value)) {
            return std::get<double>(m_value) == other;
        }
        return false;
    }
 
    inline bool operator==(int other) const {
        if (std::holds_alternative<double>(m_value)) {
            return std::get<double>(m_value) == other;
        }
        return false;
    }
 
    inline const JsonValue& operator[](const std::string& key) const {
        return operator[](key.c_str());
    }
 
    inline const JsonValue& operator[](const char* key) const {
        assert(is_object() && "JsonValue is not an object");
        return std::get<JsonObject>(m_value).at(key);
    }
 
    inline const JsonValue& operator[](size_t index) const {
        assert(is_array() && "JsonValue is not an array");
        return std::get<JsonArray>(m_value).at(index);
    }
 
  private:
    Value m_value;
};
 
class ParseError {
  public:
    template<typename... Args>
    ParseError(size_t line, size_t column, Args&&... args) :
        m_line(line),
        m_column(column) {
        std::ostringstream oss;
        (oss << ... << args);
        m_message = oss.str();
    }
 
    std::string_view message() const {
        return m_message;
    }
 
    operator std::string() const {
        return m_message;
    }
 
  private:
    std::string m_message;
    size_t m_line;
    size_t m_column;
};
 
class Parser {
  public:
    Result<JsonValue, ParseError> parse(const std::string& json);
 
  private:
    std::vector<::priv::brace::Token> m_tokens;
    size_t m_current;
 
    const ::priv::brace::Token& peek() const {
        return m_tokens[m_current];
    }
 
    const ::priv::brace::Token& advance() {
        return m_tokens[m_current++];
    }
 
    bool is_at_end() const {
        return m_current >= m_tokens.size();
    }
 
    Result<JsonValue, ParseError> parse_value();
    Result<JsonObject, ParseError> parse_object();
    Result<JsonArray, ParseError> parse_array();
};
 
}  // namespace brace
 
#endif