Json.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Json.h
 * A simple set of classes for generating JSON.
 * See http://www.json.org/
 * Copyright (C) 2012 Simon Newton
 */

#ifndef INCLUDE_OLA_WEB_JSON_H_
#define INCLUDE_OLA_WEB_JSON_H_

#include <ola/StringUtils.h>
#include <ola/base/Macro.h>
#include <map>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>

namespace ola {
namespace web {

class JsonValue {
 public:
    virtual ~JsonValue() {}

    virtual void ToString(std::ostream *output, unsigned int indent) const = 0;

 protected:
    void Indent(std::ostream *output, unsigned int indent) const {
      *output << std::string(indent, ' ');
    }

    static const unsigned int DEFAULT_INDENT = 2;
};


class JsonStringValue: public JsonValue {
 public:
    explicit JsonStringValue(const std::string &value)
        : m_value(value) {
    }

    void ToString(std::ostream *output, unsigned int) const {
      *output << '"' << EscapeString(EncodeString(m_value)) << '"';
    }

 private:
    const std::string m_value;
};


class JsonUIntValue: public JsonValue {
 public:
    explicit JsonUIntValue(unsigned int value)
        : m_value(value) {
    }

    void ToString(std::ostream *output, unsigned int) const {
      *output << m_value;
    }

 private:
    const unsigned int m_value;
};


class JsonIntValue: public JsonValue {
 public:
    explicit JsonIntValue(int value)
        : m_value(value) {
    }

    void ToString(std::ostream *output, unsigned int) const {
      *output << m_value;
    }

 private:
    const int m_value;
};


class JsonBoolValue: public JsonValue {
 public:
    explicit JsonBoolValue(bool value)
        : m_value(value) {
    }

    void ToString(std::ostream *output, unsigned int) const {
      *output << (m_value ? "true" : "false");
    }

 private:
    const bool m_value;
};


class JsonNullValue: public JsonValue {
 public:
    explicit JsonNullValue() {}

    void ToString(std::ostream *output, unsigned int) const {
      *output << "null";
    }
};


class JsonRawValue: public JsonValue {
 public:
    explicit JsonRawValue(const std::string &value)
      : m_value(value) {
    }

    void ToString(std::ostream *output, unsigned int) const {
      *output << m_value;
    }

 private:
    const std::string m_value;
};


class JsonObject: public JsonValue {
 public:
    JsonObject() {}
    ~JsonObject();

    void Add(const std::string &key, const std::string &value);

    void Add(const std::string &key, const char *value);

    void Add(const std::string &key, unsigned int i);

    void Add(const std::string &key, int i);

    void Add(const std::string &key, bool value);

    void Add(const std::string &key);

    JsonObject* AddObject(const std::string &key);

    class JsonArray* AddArray(const std::string &key);

    void AddRaw(const std::string &key, const std::string &value);

    void ToString(std::ostream *output, unsigned int indent) const;

 private:
    typedef std::map<std::string, JsonValue*> MemberMap;
    MemberMap m_members;

    DISALLOW_COPY_AND_ASSIGN(JsonObject);
};


class JsonArray: public JsonValue {
 public:
    JsonArray() : m_complex_type(false) {}
    ~JsonArray();

    void Append(const std::string &value) {
      m_values.push_back(new JsonStringValue(value));
    }

    void Append(const char *value) {
      m_values.push_back(new JsonStringValue(value));
    }

    void Append(unsigned int i) {
      m_values.push_back(new JsonUIntValue(i));
    }

    void Append(int i) {
      m_values.push_back(new JsonIntValue(i));
    }

    void Append(bool value) {
      m_values.push_back(new JsonBoolValue(value));
    }

    void Append() {
      m_values.push_back(new JsonNullValue());
    }

    JsonObject* AppendObject() {
      JsonObject *obj = new JsonObject();
      m_values.push_back(obj);
      m_complex_type = true;
      return obj;
    }

    JsonArray* AppendArray() {
      JsonArray *array = new JsonArray();
      m_values.push_back(array);
      m_complex_type = true;
      return array;
    }

    void AppendRaw(const std::string &value) {
      m_values.push_back(new JsonRawValue(value));
    }

    void ToString(std::ostream *output, unsigned int indent) const;

 private:
    typedef std::vector<JsonValue*> ValuesVector;
    ValuesVector m_values;
    // true if this array contains a nested object or array
    bool m_complex_type;

    DISALLOW_COPY_AND_ASSIGN(JsonArray);
};

class JsonWriter {
 public:
    static void Write(std::ostream *output, const JsonValue &value);

    static std::string AsString(const JsonValue &value);
};
}  // namespace web
}  // namespace ola
#endif  // INCLUDE_OLA_WEB_JSON_H_