json.h

#ifndef DBALLE_CORE_JSON_H
#define DBALLE_CORE_JSON_H
 
#include <dballe/core/fwd.h>
#include <dballe/types.h>
#include <istream>
#include <ostream>
#include <vector>
#include <wreport/var.h>
#include <wreport/varinfo.h>
 
namespace dballe {
namespace core {
 
struct JSONParseException : public std::runtime_error
{
    using std::runtime_error::runtime_error;
};

class JSONWriter
{
protected:
    enum State {
        LIST_FIRST,
        LIST,
        MAPPING_KEY_FIRST,
        MAPPING_KEY,
        MAPPING_VAL,
    };
    std::ostream& out;
    std::vector<State> stack;

    void val_head();
 
    void jputc(char c);
    void jputs(const char* s);
 
public:
    JSONWriter(std::ostream& out);
    ~JSONWriter();

    void reset();
 
    void start_list();
    void end_list();
 
    void start_mapping();
    void end_mapping();
 
    void add_null();
    void add_bool(bool val);
    void add_int(int val);
    void add_double(double val);
    void add_cstring(const char* val);
    void add_string(const std::string& val);
    template <typename T> void add_ostream(const T& val)
    {
        val_head();
        out << val;
    }
 
    void add_number(const std::string& val);
    void add_level(const Level& val);
    void add_trange(const Trange& val);
    void add_datetime(const Datetime& val);
    void add_datetimerange(const DatetimeRange& val);
    void add_coords(const Coords& val);
    void add_ident(const Ident& val);
    void add_report(const Report& val);
    void add_var(const wreport::Var& val);
    void add_station(const Station& s);
    void add_dbstation(const DBStation& s);
    void add_values(const Values& values);
    void add_dbvalues(const DBValues& values);
    void add_break();
 
    void add(const std::string& val) { add_string(val); }
    void add(const char* val) { add_cstring(val); }
    void add(double val) { add_double(val); }
    void add(int val) { add_int(val); }
    void add(bool val) { add_bool(val); }
    void add(size_t val) { add_ostream(val); }
    void add(wreport::Varcode val) { add_int(val); }
    void add(const Level& val) { add_level(val); }
    void add(const Trange& val) { add_trange(val); }
    void add(const Datetime& val) { add_datetime(val); }
    void add(const DatetimeRange& val) { add_datetimerange(val); }
    void add(const Coords& val) { add_coords(val); }
    void add(const Ident& val) { add_ident(val); }
    void add(const Report& val) { add_report(val); }
    void add(const wreport::Var& val) { add_var(val); }
    void add(const Station& s) { add_station(s); }
    void add(const DBStation& s) { add_dbstation(s); }
    void add(const Values& v) { add_values(v); }
    void add(const DBValues& v) { add_dbvalues(v); }
 
    template <typename T> void add(const char* a, T b)
    {
        add_cstring(a);
        add(b);
    }
 
    template <typename T> void add_list(const T& val)
    {
        start_list();
        for (const auto& i : val)
            add(i);
        end_list();
    }
};

class JSONReader
{
public:
    virtual ~JSONReader() {}
 
    virtual void on_start_list() = 0;
    virtual void on_end_list()   = 0;
 
    virtual void on_start_mapping() = 0;
    virtual void on_end_mapping()   = 0;
 
    virtual void on_add_null()                         = 0;
    virtual void on_add_bool(bool val)                 = 0;
    virtual void on_add_int(int val)                   = 0;
    virtual void on_add_double(double val)             = 0;
    virtual void on_add_string(const std::string& val) = 0;
 
    // Parse a stream
    void parse(std::istream& in);
};
 
namespace json {
 
enum Element {
    JSON_OBJECT,
    JSON_ARRAY,
    JSON_STRING,
    JSON_NUMBER,
    JSON_TRUE,
    JSON_FALSE,
    JSON_NULL,
};
 
struct Stream
{
    std::istream& in;
 
    Stream(std::istream& in) : in(in) {}

    void expect_token(const char* token);

    void skip_spaces();

    template <typename T> T parse_unsigned()
    {
        T res = 0;
        while (true)
        {
            int c = in.peek();
            if (c >= '0' and c <= '9')
                res = res * 10 + in.get() - '0';
            else
                break;
        }
        skip_spaces();
        return res;
    }

    template <typename T> T parse_signed()
    {
        if (in.peek() == '-')
        {
            in.get();
            return -parse_unsigned<T>();
        }
        else
            return parse_unsigned<T>();
    }

    double parse_double();

    std::tuple<std::string, bool> parse_number();

    std::string parse_string();

    Coords parse_coords();

    Station parse_station();

    DBStation parse_dbstation();

    Ident parse_ident();

    Level parse_level();

    Trange parse_trange();

    Datetime parse_datetime();

    DatetimeRange parse_datetimerange();
 
    template <typename T> inline T parse()
    {
        throw wreport::error_unimplemented();
    }

    void parse_array(std::function<void()> on_element);

    void parse_object(std::function<void(const std::string& key)> on_value);

    Element identify_next();
};
 
template <> inline std::string Stream::parse() { return parse_string(); }
template <> inline Coords Stream::parse() { return parse_coords(); }
template <> inline Station Stream::parse() { return parse_station(); }
template <> inline DBStation Stream::parse() { return parse_dbstation(); }
template <> inline Ident Stream::parse() { return parse_ident(); }
template <> inline Level Stream::parse() { return parse_level(); }
template <> inline Trange Stream::parse() { return parse_trange(); }
template <> inline Datetime Stream::parse() { return parse_datetime(); }
template <> inline DatetimeRange Stream::parse()
{
    return parse_datetimerange();
}
 
} // namespace json
 
} // namespace core
} // namespace dballe
#endif