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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 <ola/web/JsonPointer.h>
#include <stdint.h>
#include <map>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>

namespace ola {
namespace web {

class JsonObjectPropertyVisitor;
class JsonValueConstVisitorInterface;
class JsonValueVisitorInterface;

class JsonArray;
class JsonBool;
class JsonDouble;
class JsonInt64;
class JsonInt;
class JsonNull;
class JsonNumber;
class JsonObject;
class JsonRawValue;
class JsonString;
class JsonUInt64;
class JsonUInt;

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

  virtual void Visit(JsonString *value) = 0;
  virtual void Visit(JsonBool *value) = 0;
  virtual void Visit(JsonNull *value) = 0;
  virtual void Visit(JsonRawValue *value) = 0;
  virtual void Visit(JsonObject *value) = 0;
  virtual void Visit(JsonArray *value) = 0;
  virtual void Visit(JsonUInt *value) = 0;
  virtual void Visit(JsonUInt64 *value) = 0;
  virtual void Visit(JsonInt *value) = 0;
  virtual void Visit(JsonInt64 *value) = 0;
  virtual void Visit(JsonDouble *value) = 0;
};

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

  virtual void Visit(const JsonString &value) = 0;
  virtual void Visit(const JsonBool &value) = 0;
  virtual void Visit(const JsonNull &value) = 0;
  virtual void Visit(const JsonRawValue &value) = 0;
  virtual void Visit(const JsonObject &value) = 0;
  virtual void Visit(const JsonArray &value) = 0;
  virtual void Visit(const JsonUInt &value) = 0;
  virtual void Visit(const JsonUInt64 &value) = 0;
  virtual void Visit(const JsonInt &value) = 0;
  virtual void Visit(const JsonInt64 &value) = 0;
  virtual void Visit(const JsonDouble &value) = 0;
};

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

  virtual JsonValue* LookupElement(const JsonPointer &pointer);

  virtual bool operator==(const JsonValue &other) const = 0;

  virtual bool operator!=(const JsonValue &other) const {
    return !(*this == other);
  }

  virtual void Accept(JsonValueVisitorInterface *visitor) = 0;

  virtual void Accept(JsonValueConstVisitorInterface *visitor) const = 0;

  virtual JsonValue* Clone() const = 0;

  virtual JsonValue* LookupElementWithIter(JsonPointer::Iterator *iterator) = 0;

  virtual bool Equals(const JsonString &) const { return false; }

  virtual bool Equals(const JsonUInt &) const { return false; }

  virtual bool Equals(const JsonInt &) const { return false; }

  virtual bool Equals(const JsonUInt64 &) const { return false; }

  virtual bool Equals(const JsonInt64 &) const { return false; }

  virtual bool Equals(const JsonBool &) const { return false; }

  virtual bool Equals(const JsonNull &) const { return false; }

  virtual bool Equals(const JsonDouble &) const { return false; }

  virtual bool Equals(const JsonRawValue &) const { return false; }

  virtual bool Equals(const JsonObject &) const { return false; }

  virtual bool Equals(const JsonArray &) const { return false; }

  template <typename T>
  static JsonValue* NewValue(const T &value);

  template <typename T>
  static JsonNumber* NewNumberValue(const T &value);
};


class JsonLeafValue : public JsonValue {
 public:
  JsonValue* LookupElementWithIter(JsonPointer::Iterator *iter);
};

class JsonString: public JsonLeafValue {
 public:
  explicit JsonString(const std::string &value) : m_value(value) {}

  bool operator==(const JsonValue &other) const { return other.Equals(*this); }

  const std::string& Value() const { return m_value; }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonString(m_value); }

  bool Equals(const JsonString &other) const {
    return m_value == other.m_value;
  }
 private:
  const std::string m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonString);
};


class JsonNumber : public JsonLeafValue {
 public:
  virtual bool MultipleOf(const JsonNumber &other) const = 0;

  virtual bool operator<(const JsonNumber &other) const = 0;

  bool operator<=(const JsonNumber &other) const {
    return *this == other || *this < other;
  }

  bool operator>(const JsonNumber &other) const {
    return !(*this <= other);
  }

  bool operator>=(const JsonNumber &other) const {
    return !(*this < other);
  }

  virtual int Compare(const JsonUInt &value) const = 0;
  virtual int Compare(const JsonInt &value) const = 0;
  virtual int Compare(const JsonUInt64 &value) const = 0;
  virtual int Compare(const JsonInt64 &value) const = 0;
  virtual int Compare(const JsonDouble &value) const = 0;

  virtual bool FactorOf(const JsonUInt &value) const = 0;
  virtual bool FactorOf(const JsonInt &value) const = 0;
  virtual bool FactorOf(const JsonUInt64 &value) const = 0;
  virtual bool FactorOf(const JsonInt64 &value) const = 0;
  virtual bool FactorOf(const JsonDouble &value) const = 0;
};

class JsonUInt: public JsonNumber {
 public:
  explicit JsonUInt(unsigned int value) : m_value(value) {}

  bool operator==(const JsonValue &other) const { return other.Equals(*this); }

  bool operator<(const JsonNumber &other) const {
    return other.Compare(*this) == 1;
  }

  bool MultipleOf(const JsonNumber &other) const {
    return other.FactorOf(*this);
  }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonUInt(m_value); }

  unsigned int Value() const { return m_value; }

  bool Equals(const JsonUInt &other) const {
    return m_value == other.m_value;
  }

  bool Equals(const JsonInt &other) const;
  bool Equals(const JsonUInt64 &other) const;
  bool Equals(const JsonInt64 &other) const;

  int Compare(const JsonUInt &value) const;
  int Compare(const JsonInt &value) const;
  int Compare(const JsonUInt64 &value) const;
  int Compare(const JsonInt64 &value) const;
  int Compare(const JsonDouble &value) const;

  bool FactorOf(const JsonUInt &value) const;
  bool FactorOf(const JsonInt &value) const;
  bool FactorOf(const JsonUInt64 &value) const;
  bool FactorOf(const JsonInt64 &value) const;
  bool FactorOf(const JsonDouble &value) const;
 private:
  const unsigned int m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonUInt);
};


class JsonInt: public JsonNumber {
 public:
  explicit JsonInt(int value) : m_value(value) {}

  bool operator==(const JsonValue &other) const { return other.Equals(*this); }

  bool operator<(const JsonNumber &other) const {
    return other.Compare(*this) == 1;
  }

  bool MultipleOf(const JsonNumber &other) const {
    return other.FactorOf(*this);
  }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonInt(m_value); }

  int Value() const { return m_value; }

  bool Equals(const JsonInt &other) const {
    return m_value == other.m_value;
  }

  bool Equals(const JsonUInt &other) const;
  bool Equals(const JsonUInt64 &other) const;
  bool Equals(const JsonInt64 &other) const;

  int Compare(const JsonUInt &value) const;
  int Compare(const JsonInt &value) const;
  int Compare(const JsonUInt64 &value) const;
  int Compare(const JsonInt64 &value) const;
  int Compare(const JsonDouble &value) const;

  bool FactorOf(const JsonUInt &value) const;
  bool FactorOf(const JsonInt &value) const;
  bool FactorOf(const JsonUInt64 &value) const;
  bool FactorOf(const JsonInt64 &value) const;
  bool FactorOf(const JsonDouble &value) const;
 private:
  const int m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonInt);
};


class JsonUInt64: public JsonNumber {
 public:
  explicit JsonUInt64(uint64_t value) : m_value(value) {}

  bool operator==(const JsonValue &other) const {
    return other.Equals(*this);
  }

  bool operator<(const JsonNumber &other) const {
    return other.Compare(*this) == 1;
  }

  bool MultipleOf(const JsonNumber &other) const {
    return other.FactorOf(*this);
  }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonUInt64(m_value); }

  uint64_t Value() const { return m_value; }

  bool Equals(const JsonUInt64 &other) const {
    return m_value == other.m_value;
  }

  bool Equals(const JsonUInt &other) const;
  bool Equals(const JsonInt &other) const;
  bool Equals(const JsonInt64 &other) const;

  int Compare(const JsonUInt &value) const;
  int Compare(const JsonInt &value) const;
  int Compare(const JsonUInt64 &value) const;
  int Compare(const JsonInt64 &value) const;
  int Compare(const JsonDouble &value) const;

  bool FactorOf(const JsonUInt &value) const;
  bool FactorOf(const JsonInt &value) const;
  bool FactorOf(const JsonUInt64 &value) const;
  bool FactorOf(const JsonInt64 &value) const;
  bool FactorOf(const JsonDouble &value) const;
 private:
  const uint64_t m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonUInt64);
};


class JsonInt64: public JsonNumber {
 public:
  explicit JsonInt64(int64_t value) : m_value(value) {}

  bool operator==(const JsonValue &other) const {
    return other.Equals(*this);
  }

  bool operator<(const JsonNumber &other) const {
    return other.Compare(*this) == 1;
  }

  bool MultipleOf(const JsonNumber &other) const {
    return other.FactorOf(*this);
  }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonInt64(m_value); }

  int64_t Value() const { return m_value; }

  bool Equals(const JsonInt64 &other) const {
    return m_value == other.m_value;
  }

  bool Equals(const JsonUInt &other) const;
  bool Equals(const JsonInt &other) const;
  bool Equals(const JsonUInt64 &other) const;

  int Compare(const JsonUInt &value) const;
  int Compare(const JsonInt &value) const;
  int Compare(const JsonUInt64 &value) const;
  int Compare(const JsonInt64 &value) const;
  int Compare(const JsonDouble &value) const;

  bool FactorOf(const JsonUInt &value) const;
  bool FactorOf(const JsonInt &value) const;
  bool FactorOf(const JsonUInt64 &value) const;
  bool FactorOf(const JsonInt64 &value) const;
  bool FactorOf(const JsonDouble &value) const;
 private:
  const int64_t m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonInt64);
};


class JsonDouble: public JsonNumber {
 public:
  struct DoubleRepresentation {
    bool is_negative;
    uint64_t full;
    uint32_t leading_fractional_zeros;
    uint64_t fractional;
    int32_t exponent;
  };

  explicit JsonDouble(double value);

  explicit JsonDouble(const DoubleRepresentation &rep);

  bool operator==(const JsonValue &other) const {
    return other.Equals(*this);
  }

  bool operator<(const JsonNumber &other) const {
    return other.Compare(*this) == 1;
  }

  bool MultipleOf(const JsonNumber &other) const {
    return other.FactorOf(*this);
  }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  const std::string& ToString() const { return m_as_string; }

  double Value() const { return m_value; }

  static bool AsDouble(const DoubleRepresentation &rep, double *out);

  static std::string AsString(const DoubleRepresentation &rep);

  JsonValue* Clone() const {
    // This loses precision, maybe we should fix it?
    return new JsonDouble(m_value);
  }

  bool Equals(const JsonDouble &other) const {
    // This is sketchy. The standard says "have the same mathematical value"
    // TODO(simon): Think about this some more.
    return m_value == other.m_value;
  }

  int Compare(const JsonUInt &value) const;
  int Compare(const JsonInt &value) const;
  int Compare(const JsonUInt64 &value) const;
  int Compare(const JsonInt64 &value) const;
  int Compare(const JsonDouble &value) const;

  bool FactorOf(const JsonUInt &value) const;
  bool FactorOf(const JsonInt &value) const;
  bool FactorOf(const JsonUInt64 &value) const;
  bool FactorOf(const JsonInt64 &value) const;
  bool FactorOf(const JsonDouble &value) const;
 private:
  double m_value;
  std::string m_as_string;

  DISALLOW_COPY_AND_ASSIGN(JsonDouble);
};


class JsonBool: public JsonLeafValue {
 public:
  explicit JsonBool(bool value) : m_value(value) {}

  bool operator==(const JsonValue &other) const {
    return other.Equals(*this);
  }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonBool(m_value); }

  bool Value() const { return m_value; }

  bool Equals(const JsonBool &other) const {
    return m_value == other.m_value;
  }
 private:
  const bool m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonBool);
};


class JsonNull: public JsonLeafValue {
 public:
  JsonNull() {}

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonNull(); }

  bool operator==(const JsonValue &other) const { return other.Equals(*this); }

  bool Equals(const JsonNull &) const { return true; }
 private:
  DISALLOW_COPY_AND_ASSIGN(JsonNull);
};


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

  bool operator==(const JsonValue &other) const { return other.Equals(*this); }

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const { return new JsonRawValue(m_value); }

  const std::string& Value() const { return m_value; }

  bool Equals(const JsonRawValue &other) const {
    return m_value == other.m_value;
  }
 private:
  const std::string m_value;

  DISALLOW_COPY_AND_ASSIGN(JsonRawValue);
};


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

  JsonValue* LookupElementWithIter(JsonPointer::Iterator *iter);

  bool operator==(const JsonValue &other) const {
    return other.Equals(*this);
  }

  bool Equals(const JsonObject &other) const;

  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, double d);

  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 AddValue(const std::string &key, JsonValue *value);

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

  bool Remove(const std::string &key);

  bool ReplaceValue(const std::string &key, JsonValue *value);

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const;

  bool IsEmpty() const { return m_members.empty(); }

  unsigned int Size() const { return m_members.size(); }

  void VisitProperties(JsonObjectPropertyVisitor *visitor) 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();

  JsonValue* LookupElementWithIter(JsonPointer::Iterator *iter);

  bool operator==(const JsonValue &other) const {
    return other.Equals(*this);
  }

  bool Equals(const JsonArray &other) const;

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

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

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

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

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

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

  void Append(JsonValue *value) {
    m_values.push_back(value);
  }

  void Append(JsonObject *value) {
    m_values.push_back(value);
    m_complex_type |= !value->IsEmpty();
  }

  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 AppendValue(JsonValue *value) {
    m_values.push_back(value);
  }

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

  bool RemoveElementAt(uint32_t index);

  bool ReplaceElementAt(uint32_t index, JsonValue *value);

  bool InsertElementAt(uint32_t index, JsonValue *value);

  void Accept(JsonValueVisitorInterface *visitor) { visitor->Visit(this); }
  void Accept(JsonValueConstVisitorInterface *visitor) const {
    visitor->Visit(*this);
  }

  JsonValue* Clone() const;

  bool IsEmpty() const { return m_values.empty(); }

  unsigned int Size() const { return m_values.size(); }

  const JsonValue *ElementAt(unsigned int i) const;

  bool IsComplexType() const { return m_complex_type; }

 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 JsonObjectPropertyVisitor {
 public:
  virtual ~JsonObjectPropertyVisitor() {}

  virtual void VisitProperty(const std::string &property,
                             const JsonValue &value) = 0;
};

JsonObject* ObjectCast(JsonValue *value);

JsonArray* ArrayCast(JsonValue *value);

// operator<<
std::ostream& operator<<(std::ostream &os, const JsonString &value);
std::ostream& operator<<(std::ostream &os, const JsonUInt &value);
std::ostream& operator<<(std::ostream &os, const JsonInt &value);
std::ostream& operator<<(std::ostream &os, const JsonUInt64 &value);
std::ostream& operator<<(std::ostream &os, const JsonInt64 &value);
std::ostream& operator<<(std::ostream &os, const JsonDouble &value);
std::ostream& operator<<(std::ostream &os, const JsonBool &value);
std::ostream& operator<<(std::ostream &os, const JsonNull &value);
std::ostream& operator<<(std::ostream &os, const JsonRawValue &value);

// JsonValue::NewNumberValue implementations.
template <>
inline JsonNumber* JsonValue::NewNumberValue<uint32_t>(
    const uint32_t &value) {
  return new JsonUInt(value);
}

template <>
inline JsonNumber* JsonValue::NewNumberValue<int32_t>(
    const int32_t &value) {
  return new JsonInt(value);
}

template <>
inline JsonNumber* JsonValue::NewNumberValue<uint64_t>(
    const uint64_t &value) {
  return new JsonUInt64(value);
}

template <>
inline JsonNumber* JsonValue::NewNumberValue<int64_t>(
    const int64_t &value) {
  return new JsonInt64(value);
}

template <>
inline JsonNumber* JsonValue::NewNumberValue<double>(
    const double &value) {
  return new JsonDouble(value);
}

template <>
inline JsonNumber* JsonValue::NewNumberValue<
    JsonDouble::DoubleRepresentation>(
    const JsonDouble::DoubleRepresentation &value) {
  return new JsonDouble(value);
}

// JsonValue::NewValue implementations.
template <>
inline JsonValue* JsonValue::NewValue<std::string>(const std::string &value) {
  return new JsonString(value);
}

template <>
inline JsonValue* JsonValue::NewValue<uint32_t>(const uint32_t &value) {
  return NewNumberValue(value);
}

template <>
inline JsonValue* JsonValue::NewValue<int32_t>(const int32_t &value) {
  return NewNumberValue(value);
}

template <>
inline JsonValue* JsonValue::NewValue<uint64_t>(const uint64_t &value) {
  return NewNumberValue(value);
}

template <>
inline JsonValue* JsonValue::NewValue<int64_t>(const int64_t &value) {
  return NewNumberValue(value);
}

template <>
inline JsonValue* JsonValue::NewValue<double>(const double &value) {
  return NewNumberValue(value);
}

template <>
inline JsonValue* JsonValue::NewValue<JsonDouble::DoubleRepresentation>(
    const JsonDouble::DoubleRepresentation &value) {
  return NewNumberValue(value);
}

template <>
inline JsonValue* JsonValue::NewValue<bool>(const bool &value) {
  return new JsonBool(value);
}
}  // namespace web
}  // namespace ola
#endif  // INCLUDE_OLA_WEB_JSON_H_