dxjson.h

Go to the documentation of this file.

// Copyright (C) 2013-2016 DNAnexus, Inc.
//
// This file is part of dx-toolkit (DNAnexus platform client libraries).
//
//   Licensed under the Apache License, Version 2.0 (the "License"); you may
//   not use this file except in compliance with the License. You may obtain a
//   copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
//   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
//   License for the specific language governing permissions and limitations
//   under the License.
 
#ifndef __DXJSON_H__
#define __DXJSON_H__
 
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
#include <cstdlib>
#include <string>
#include <iostream>
#include <cstdio>
#include <exception>
#include <cassert>
#include <sstream>
#include <istream>
#include <ostream>
#include <limits>
#include <typeinfo>
#include <cmath>
#include <algorithm>
#include <stdint.h>
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/lexical_cast.hpp>
 
#include "utf8/utf8.h"
 
 
// NOTE:
// 1) UTF-8 validity is checked while reading JSON from a string;
// 2) UTF-8
 
namespace dx {
 
  class JSONException:public std::exception {
  public:
    std::string err;
    JSONException(const std::string &e): err(e) {}
    const char* what() const throw() {
      return (const char*)err.c_str();
    }
    ~JSONException() throw() { }
  };
  
  template<typename T> void assertValidityOfNumericType(const T &value) {
    assert (std::numeric_limits<T>::is_specialized); // We should never call this function for non-numeric types
    if (boost::math::isnan(value) || !boost::math::isfinite(value)) { 
      throw JSONException("Illegal floating point value. JSON spec do not allow NaN/Inifnity values for numbers. Value provided = '" + boost::lexical_cast<std::string>(value) + "'");
    }
  }
 
  enum JSONValue {
    JSON_UNDEFINED = 0,
    JSON_OBJECT = 1,
    JSON_HASH = 1, // JSON_HASH and JSON_OBJECT are aliases (both have value = 1)
    JSON_ARRAY = 2,
    JSON_INTEGER = 3,
    JSON_REAL = 4,
    JSON_STRING = 5,
    JSON_BOOLEAN = 6,
    JSON_NULL = 7
  };
 
  class Value {
  public:
    virtual JSONValue type() const = 0; // Return type of particular derived class
    virtual void write(std::ostream &out) const = 0;
    virtual Value* returnMyNewCopy() const = 0;
    virtual void read(std::istream &in) = 0;
    virtual bool isEqual(const Value* other) const = 0;
    virtual ~Value() { }
  };
 
  // Forward declarations
  class Integer;
  class Real;
  class Null;
  class Boolean;
  class String;
  class Array;
  class Object;
 
  class JSON {
  public:
    
    typedef std::map<std::string, JSON>::iterator object_iterator;
    typedef std::map<std::string, JSON>::const_iterator const_object_iterator;
    typedef std::vector<JSON>::iterator array_iterator;
    typedef std::vector<JSON>::const_iterator const_array_iterator;
 
    typedef std::map<std::string, JSON>::const_reverse_iterator object_reverse_iterator;
    typedef std::map<std::string, JSON>::reverse_iterator const_object_reverse_iterator;
    typedef std::vector<JSON>::reverse_iterator array_reverse_iterator;
    typedef std::vector<JSON>::const_reverse_iterator const_array_reverse_iterator;
 
    Value *val;
 
    static double getEpsilon();
 
    static JSON parse(const std::string &str) {
      JSON tmp;
      tmp.readFromString(str);
      return tmp;
    }
 
    JSON():val(NULL) {}
 
    JSON(const JSON &rhs);
 
    JSON(const JSONValue &rhs);
 
    template<typename T>
    JSON(const T& x);
 
    void clear() { delete val; val=NULL; }
 
    void write(std::ostream &out) const;
 
    void read(std::istream &in);
 
    void readFromString(const std::string &jstr); // Populate JSON from a string
 
    std::string toString(bool onlyTopLevel = false) const;
 
    bool operator ==(const JSON& other) const;
 
    bool operator !=(const JSON& other) const { return !(*this == other); }
 
    const JSON& operator [](const size_t &indx) const;
 
    const JSON& operator [](const std::string &s) const;
 
    const JSON& operator [](const JSON &j) const;
 
    const JSON& operator [](const char *str) const;
 
    template<typename T>
    const JSON& operator [](const T&x) const;
 
    JSON& operator [](const size_t &indx);
 
    JSON& operator [](const std::string &s);
 
    JSON& operator [](const JSON &j);
 
    JSON& operator [](const char *str);
 
    template<typename T>
    JSON& operator [](const T& x) { return const_cast<JSON&>( (*(const_cast<const JSON*>(this)))[x]); }
 
    template<typename T> JSON& operator =(const T &rhs);
    
    JSON& operator =(const JSON &);
    
    JSON& operator =(const JSONValue&);
 
    JSON& operator =(const char &c);
 
    JSON& operator =(const std::string &s);
 
    JSON& operator =(const bool &x);
 
    JSON& operator =(const char s[]);
 
    JSON& operator =(const Null &x);
 
    template<typename T>
    JSON& operator =(const std::vector<T> &vec);
 
    template<typename T>
    JSON& operator =(const std::map<std::string, T> &m);
 
    template<typename T>
    operator T() const;
 
    template<typename T>
    T get() const {
      // Reuses the conversion operator: operator T()
      return static_cast<T>(*this);
    }
 
    JSONValue type() const { return (val == NULL) ? JSON_UNDEFINED : val->type(); }
 
    void resize_array(size_t desired_size);
 
    size_t size() const;
 
    size_t length() const { return size(); }
 
    template<typename T>
    bool has(const T &indx) const { return has(static_cast<size_t>(indx)); }
 
    bool has(const size_t &indx) const;
 
    bool has(const std::string &key) const;
 
    bool has(const JSON &j) const;
 
    bool has(const char *key) const;
 
    void push_back(const JSON &j);
 
    void erase(const size_t &indx);
 
    void erase(const std::string &key);
 
    const_object_iterator object_begin() const;
 
    object_iterator object_begin();
    
    const_array_iterator array_begin() const;
    
    array_iterator array_begin();
    
    const_object_iterator object_end() const;
    
    object_iterator object_end();
    
    const_array_iterator array_end() const;
    
    array_iterator array_end();
    
    const_array_reverse_iterator array_rbegin() const;
    
    array_reverse_iterator array_rbegin();
    
    const_array_reverse_iterator array_rend() const;
    
    array_reverse_iterator array_rend();
 
    ~JSON() { clear(); }
  };
 
  class Integer: public Value {
  public:
    int64_t val;
 
    Integer() {}
    Integer(const int64_t &v): val(v) {}
    void write(std::ostream &out) const { out << val; }
    JSONValue type() const { return JSON_INTEGER; }
    size_t returnAsArrayIndex() const { return static_cast<size_t>(val);}
    Value* returnMyNewCopy() const { return new Integer(*this); }
    operator const Value* () { return this; }
    bool isEqual(const Value *other) const;
    bool operator ==(const Integer& other) const { return isEqual(&other); }
    bool operator !=(const Integer &other) const { return !(*this == other); }
 
    // read() Should not be called for Integer and Real,
    // use ReadNumberValue() instead for these two "special" classes
    void read(std::istream &in __attribute__ ((unused)) ) { assert(false); }
  };
 
  class Real: public Value {
  public:
    double val;
 
    Real() {}
    Real(const double &v) {
      assertValidityOfNumericType(v);
      val = v;
    }
    void write(std::ostream &out) const { out << val; }
    JSONValue type() const { return JSON_REAL; }
    size_t returnAsArrayIndex() const { return static_cast<size_t>(val);}
    Value* returnMyNewCopy() const { return new Real(*this); }
    bool isEqual(const Value *other) const;
    bool operator ==(const Real& other) const { return isEqual(&other); }
    bool operator !=(const Real& other) const { return !(*this == other); }
 
    // read() Should not be called for Integer and Real,
    // use ReadNumberValue() instead for these two "special" classes
    void read(std::istream &in __attribute__ ((unused)) ) { assert(false); }
  };
 
  class String: public Value {
  public:
    std::string val;
 
    String() {}
    String(const std::string &v):val(v) {}
    // TODO: Make sure cout << stl::string works as expected;
    void write(std::ostream &out) const;
    JSONValue type() const { return JSON_STRING; }
    std::string returnString() const { return val; }
    Value* returnMyNewCopy() const { return new String(*this); }
    void read(std::istream &in);
    bool isEqual(const Value *other) const;
    bool operator ==(const String& other) const { return isEqual(&other); }
    bool operator !=(const String& other) const { return !(*this == other); }
 
    // Should have a constructor which allows creation from std::string directly.
  };
 
  class Object: public Value {
  public:
    std::map<std::string, JSON> val;
 
    Object() { }
    Object(const Object &rhs): val(rhs.val) {}
 
    template<typename T>
    Object(const std::map<std::string, T> &v) {
      val.insert(v.begin(), v.end());
    }
 
    JSON& jsonAtKey(const std::string &s);
    const JSON& jsonAtKey(const std::string &s) const;
    void write(std::ostream &out) const;
    JSONValue type() const { return JSON_OBJECT; }
    Value* returnMyNewCopy() const { return new Object(*this); }
    void read(std::istream &in);
    void erase(const std::string &key);
    bool isEqual(const Value *other) const;
    bool operator ==(const Object& other) const { return isEqual(&other); }
    bool operator !=(const Object& other) const { return !(*this == other); }
  };
 
  class Array: public Value {
  public:
    std::vector<JSON> val;
 
    Array() { }
    Array(const Array& arr): val(arr.val) {}
 
    template<typename T>
    Array(const std::vector<T> &vec) {
      for (unsigned i = 0;i < vec.size(); i++) {
        JSON tmp(vec[i]);
        val.push_back(tmp);
      }
    }
 
    const JSON& jsonAtIndex(size_t i) const;
    void write(std::ostream &out) const;
    JSONValue type() const { return JSON_ARRAY; }
    Value* returnMyNewCopy() const { return new Array(*this); }
    void read(std::istream &in);
    void push_back(const JSON &j) {
      val.push_back(j);
    }
    void erase(const size_t &i);
    bool isEqual(const Value* other) const;
    bool operator ==(const Array& other) const { return isEqual(&other); }
    bool operator !=(const Array& other) const { return !(*this == other); }
 
  };
 
  class Boolean: public Value {
  public:
    bool val;
 
    Boolean() {}
    Boolean(const bool &v):val(v) {}
    JSON& jsonAtKey(const std::string &s);
    const JSON& jsonAtKey(const std::string &s) const;
    JSONValue type() const { return JSON_BOOLEAN; }
    void write(std::ostream &out) const { out << ((val) ? "true" : "false"); }
    Value* returnMyNewCopy() const { return new Boolean(*this); }
    void read(std::istream &in);
    bool isEqual(const Value* other) const;
    bool operator ==(const Boolean& other) const { return isEqual(&other); }
    bool operator !=(const Boolean& other) const { return !(*this == other); }
  };
 
  class Null: public Value {
  public:
    void write(std::ostream &out) const { out << "null"; }
    JSONValue type() const { return JSON_NULL; }
    Value* returnMyNewCopy() const { return new Null(*this); }
    void read(std::istream &in);
    bool isEqual(const Value* other) const;
    bool operator ==(const Null& other) const { return isEqual(&other); }
    bool operator !=(const Null& other) const { return !(*this == other); }
 
  };
 
  template<typename T>
  JSON::JSON(const T& x) {
    val = NULL; // So that clear() works fine on this, else we will be deallocating some arbitrary memory - dangerous!
    *this = operator=(x);
  }
 
 
  template<typename T>
  JSON& JSON::operator =(const T &x) {
    if (!std::numeric_limits<T>::is_specialized)
      throw JSONException("Sorry! We do not allow creating a JSON object from " + std::string(typeid(x).name()) + " type.");
 
    if (!std::numeric_limits<T>::is_integer)
      assertValidityOfNumericType(x);
 
    clear();
    if(std::numeric_limits<T>::is_integer)
      this->val = new Integer(static_cast<int64_t>(x));
    else
      this->val = new Real(static_cast<double>(x));
    return *this;
  }
 
  template<typename T>
  JSON& JSON::operator =(const std::vector<T> &vec) {
    clear();
    this->val = new Array(vec);
    return *this;
  }
 
  template<typename T>
  JSON& JSON::operator =(const std::map<std::string, T> &m) {
    clear();
    this->val = new Object(m);
    return *this;
  }
 
  template<typename T>
  JSON::operator T() const {
    JSONValue typ = this->type();
    if (typ != JSON_INTEGER && typ != JSON_REAL && typ != JSON_BOOLEAN)
      throw JSONException("No typecast available for this JSON object to a Numeric/Boolean type");
 
    if (!std::numeric_limits<T>::is_specialized)
      throw JSONException("You cannot convert this JSON object to Numeric/Boolean type.");
 
    switch(typ) {
      case JSON_INTEGER:
        return static_cast<T>( ((Integer*)this->val)->val);
      case JSON_REAL:
        return static_cast<T>( ((Real*)this->val)->val);
      case JSON_BOOLEAN:
        return static_cast<T>( ((Boolean*)this->val)->val);
      default: assert(false); // Should never happen (already checked at top)
    }
  }
 
  template<typename T>
  const JSON& JSON::operator [](const T&x) const {
    return (*(const_cast<const JSON*>(this)))[static_cast<size_t>(x)];
  }
 
  template<>
  inline std::string JSON::get<std::string>() const {
    if (this->type() != JSON_STRING)
      throw JSONException("You cannot use get<std::string>/get<char*> for a non JSON_STRING value");
    return ((String*)this->val)->val;
  }
 
}
 
#endif