json.h

/*
 * Basic JSON parse
 */

#ifndef MTLD_JSON_H
#define MTLD_JSON_H
#include <string>
#include <iostream>
#include <vector>
#include <mtld/exception.h>
#include <mtld/common.h>
#include <stdlib.h>

namespace Mobi { namespace Mtld { namespace JSON {

// Identifies type of JSON construct
enum Type {
    Array,
    Object,
    Number,
    String
};

// pretty-printer for JSON data.
std::ostream &operator<< (std::ostream &, const Type &);

class FormatError : public Exception {};

// Basic parser.
class Parser {
    std::istream &f; // data stream to parse
    unsigned char peek(); // peek at next character
    unsigned char read(); // consume next character.
public:
    Parser(std::istream &f_) : f(f_) {}

    // Parse one primitive item from the stream
    void parseString(std::string &);
    template <typename I> void parseInt(I &); // templatise for different integer types.
    void parseFloat(double &);

    void skipAny(); // skips over the next field, irrespective of type.

    /*
     * parse an object calling back into
     * Context::parseField(this, fieldname) for each constituent object.
     */

    template <typename Context> void parseObject(Context &ctx);

    /*
     * parse an array calling back into
     * Context::parseElement(this, index) for each constituent object.
     */
    template <typename Context> void parseArray(Context &ctx);

    // Peek at the type of the next object in the stream
    Type peekType();

    // consume whitespace, and return a peek at the next character.
    unsigned char startNextToken();
    ~Parser() {}
};

template <typename N>
void
Parser::parseInt(N &in)
{
    int sign = 1;
    char c = startNextToken();
    if (c == '-') {
        read();
        c = peek();
        sign = -1;
    } else if (!isdigit(c)) {
        throw FormatError();
    }
    for (in = 0; isdigit(c); c = peek()) {
        read();
        in *= 10;
        in += c - '0';
    };
    in *= sign;
}

template <typename Context>
void
Parser::parseArray(Context &ctx)
{
    int c = startNextToken();
    if (c != '[')
        throw FormatError();
    read();
    if ((c = startNextToken()) == ']')
        return; // empty array

    for (size_t i = 0;; i++) {
        startNextToken();
        ctx.parseElement(this, i);

        c = startNextToken();
        read();
        switch (c) {
            case ']':
                return;
            case ',':
                break;
            default:
                throw FormatError();
        }
    }
}

template <typename Context>
void
Parser::parseObject(Context &ctx)
{
    // An object is a list of pairs.
    int c = startNextToken();
    if (c != '{')
        throw FormatError();
    read();
    for (;;) {
        std::string fieldName;
        switch (startNextToken()) {
            case '"': // Name of next field.
                parseString(fieldName);
                c = startNextToken();
                read();
                if (c != ':')
                    throw FormatError();
                ctx.parseField(this, fieldName);
                break;

            case '}': // End of this object
                read();
                return;

            case ',': // Separator to next field
                read();
                break;

            default:
                throw FormatError();
        }
    }
}

// For parsing simple vector types:
// VectorArrayParser<std::string, parseStringF> would be a candidate argument for the parseArray template.

template <typename VT, typename Func>
class VectorArrayParser {
    std::vector<VT> &values;
    Func f;
    public:
    void parseElement(Parser *j, size_t idx) {
        if (values.size() <= idx)
            values.resize(idx + 1);
        f(j, values[idx]);
    }
    VectorArrayParser(std::vector<VT> &values_, Func f_ = Func()) : values(values_), f(f_) {}
};

// This is a special case parser for objects where the keys are indexes into an array.
// This can me more compact than an array where most of the elements take a default value

template <typename VT, typename Func>
class SparseArrayParser {
    std::vector<VT> &values;
    Func f;
public:
    void parseField(Parser *j, std::string field) {
        const char *p = field.c_str();
        unsigned long idx = 0;
        try {
            idx = Mobi::Mtld::Da::ValueChecker::atou<unsigned long>(p);
            if (values.size() <= idx)
                values.resize(idx + 1);
            f(j, values[idx]);
        } catch (Exception &e) {
            e << " (parse json field)";
            throw e;
        }
    }
    SparseArrayParser(std::vector<VT> &values_, Func f_ = Func()) : values(values_), f(f_) {}
};

struct parseStringF { 
    void operator () (Parser *j, std::string &s) { j->parseString(s); }
};

template <typename IntegerType = int> struct parseIntF { 
    void operator () (Parser *j, IntegerType &i) { j->parseInt(i); }
};

template <typename Object, typename ObjectParser> struct parseObjectF { 
    void operator () (JSON::Parser *j, Object &o) {
        ObjectParser p(o);
        j->parseObject(p);
    }
};


}}}
#endif