jsonParser.hh

Go to the documentation of this file.

#ifndef CASM_JSONPARSER_HH
#define CASM_JSONPARSER_HH

#include "casm/external/json_spirit/json_spirit_reader_template.h"
#include "casm/external/json_spirit/json_spirit_writer_template.h"

#include "casm/misc/CASM_TMP.hh"

#include <exception>
#include <complex>

#include "casm/external/boost.hh"

namespace CASM {

  template<bool IsConst>
  class jsonParserIterator;

  class jsonParser : public json_spirit::mValue {

  public:

    typedef json_spirit::mObject::size_type size_type;
    typedef jsonParserIterator<false> iterator;
    typedef jsonParserIterator<true> const_iterator;

    // ---- Constructors  ----------------------------------

    jsonParser() :
      json_spirit::mValue(json_spirit::mObject()) {}

    template<typename T>
    explicit jsonParser(T &t) {
      to_json(t, *this);
    }

    template<typename T>
    explicit jsonParser(const T &t) {
      to_json(t, *this);
    }


    // ---- Read/Print JSON  ----------------------------------

    bool read(std::istream &stream);

    bool read(const boost::filesystem::path &mypath);


    void print(std::ostream &stream, unsigned int indent = 2, unsigned int prec = 12) const;

    void write(const std::string &file_name, unsigned int indent = 2, unsigned int prec = 12) const;

    void write(const boost::filesystem::path &mypath, unsigned int indent = 2, unsigned int prec = 12) const;


    // ---- Value level printing options: ---------------------

    using json_spirit::mValue::set_force_column;

    using json_spirit::mValue::set_force_row;

    using json_spirit::mValue::set_scientific;

    using json_spirit::mValue::set_remove_trailing_zeros;

    using json_spirit::mValue::unset_force_column;

    using json_spirit::mValue::unset_force_row;

    using json_spirit::mValue::unset_scientific;

    using json_spirit::mValue::unset_remove_trailing_zeros;


    using json_spirit::mValue::operator==;

    bool operator!=(const jsonParser &json) const {
      return !(json_spirit::mValue::operator==(json));
    }

    bool almost_equal(const jsonParser &B, double tol) const;


    // ------ Type Checking Methods ------------------------------------

    bool is_null() const;
    bool is_bool() const;
    bool is_int() const;
    bool is_number() const;
    bool is_string() const;
    bool is_obj() const;
    bool is_array() const;


    // ---- Navigate the JSON data: ----------------------------

    jsonParser &operator[](const std::string &name);

    const jsonParser &operator[](const std::string &name) const;

    jsonParser &at(const fs::path &path);

    const jsonParser &at(const fs::path &path) const;

    jsonParser &operator[](const int &element);

    const jsonParser &operator[](const int &element) const;

    size_type size() const;

    iterator begin();

    const_iterator begin() const;

    iterator end();

    const_iterator end() const;

    const_iterator cbegin() const;

    const_iterator cend() const;


    iterator find(const std::string &name);

    const_iterator find(const std::string &name) const;

    bool contains(const std::string &name) const;

    size_type erase(const std::string &name);

    // ---- Data-retrieval Methods -----------------------------------------

    template<typename T, typename...Args>
    T get(Args... args) const;

    template<typename T, typename...Args>
    void get(T &t, Args... args) const;

    template<typename T, typename...Args>
    bool get_if(T &t, const std::string &key, Args... args) const;

    template<typename T, typename...Args>
    bool get_else(T &t, const std::string &key, const T &default_value, Args... args) const;


    // ---- Data addition Methods (Overwrites any existing data with same 'name') ---

    template<typename T>
    jsonParser &operator=(const T &value);

    template<typename T>
    jsonParser &push_back(const T &value);

    template<typename T>
    jsonParser &put(const T &value);

    jsonParser &put_obj() {
      return *this = object();
    }

    template<typename Iterator>
    jsonParser &put_obj(Iterator begin, Iterator end);

    jsonParser &put_array() {
      return *this = array();
    }

    jsonParser &put_array(size_type N) {
      return *this = array(N);
    }

    template<typename T>
    jsonParser &put_array(size_type N, const T &t);

    template<typename Iterator>
    jsonParser &put_array(Iterator begin,
                          Iterator end,
                          typename CASM_TMP::enable_if_iterator<Iterator>::type * = nullptr);

    jsonParser &put_null() {
      return *this = null();
    }

    // ---- static Methods -------------------------------------

    static jsonParser parse(const std::string &str) {
      std::stringstream ss;
      ss << str;
      return jsonParser(ss);
    }

    static jsonParser parse(const fs::path &path) {
      return jsonParser(path);
    }

    static jsonParser parse(std::istream &stream) {
      return jsonParser(stream);
    }

    static jsonParser object() {
      jsonParser json;
      return json = json_spirit::mValue(json_spirit::mObject());
    }

    template<typename Iterator>
    static jsonParser object(Iterator begin, Iterator end) {
      jsonParser json;
      return json.put_obj(begin, end);
    }

    static jsonParser array() {
      jsonParser json;
      return json = json_spirit::mValue(json_spirit::mArray());
    }

    static jsonParser array(size_type N) {
      jsonParser json;
      return json = json_spirit::mValue(json_spirit::mArray(N));
    }

    template<typename T>
    static jsonParser array(size_type N, const T &t) {
      jsonParser json;
      return json.put_array(N, t);
    }

    template<typename Iterator>
    static jsonParser array(Iterator begin,
                            Iterator end,
                            typename CASM_TMP::enable_if_iterator<Iterator>::type * = nullptr) {
      jsonParser json;
      return json.put_array(begin, end);
    }


    static jsonParser null() {
      jsonParser json;
      return json = json_spirit::mValue();
    }

  private:

    jsonParser &operator=(const json_spirit::mValue &value) {
      this->json_spirit::mValue::operator=(value);
      return *this;
    }


  };

  std::ostream &operator<<(std::ostream &stream, const jsonParser &json);
  std::istream &operator>>(std::istream &stream, jsonParser &json);

  jsonParser &to_json(bool value, jsonParser &json);
  jsonParser &to_json(int value, jsonParser &json);
  jsonParser &to_json(unsigned int value, jsonParser &json);
  jsonParser &to_json(long int value, jsonParser &json);
  jsonParser &to_json(unsigned long int value, jsonParser &json);
  jsonParser &to_json(double value, jsonParser &json);
  jsonParser &to_json(const std::string &value, jsonParser &json);
  jsonParser &to_json(const char *value, jsonParser &json);
  jsonParser &to_json(const jsonParser &value, jsonParser &json);


  template<typename T>
  T from_json(const jsonParser &json);


  template<> bool from_json<bool>(const jsonParser &json);
  template<> int from_json<int>(const jsonParser &json);
  template<> unsigned int from_json<unsigned int>(const jsonParser &json);
  template<> long int from_json<long int>(const jsonParser &json);
  template<> unsigned long int from_json<unsigned long int>(const jsonParser &json);
  template<> double from_json<double>(const jsonParser &json);
  template<> std::string from_json<std::string>(const jsonParser &json);
  template<> jsonParser from_json<jsonParser>(const jsonParser &json);

  void from_json(bool &value, const jsonParser &json);
  void from_json(int &value, const jsonParser &json);
  void from_json(unsigned int &value, const jsonParser &json);
  void from_json(long int &value, const jsonParser &json);
  void from_json(unsigned long int &value, const jsonParser &json);
  void from_json(double &value, const jsonParser &json);
  void from_json(std::string &value, const jsonParser &json);
  void from_json(jsonParser &value, const jsonParser &json);
  void from_json(std::istream &stream, const jsonParser &json);
  void from_json(fs::path &value, const jsonParser &json);

  inline void to_json(std::istream &stream, jsonParser &json) {
    if(!json.read(stream)) {
      throw std::runtime_error(
        std::string("ERROR: Could not read JSON. Please check your formatting. "
                    "For instance, try http://www.jsoneditoronline.org."));
    }
  }

  inline void to_json(fs::path file_path, jsonParser &json) {
    if(!json.read(file_path)) {
      throw std::runtime_error(
        std::string("ERROR: Could not read JSON file: '") + file_path.string() +
        "'.\n\nPlease check your formatting. For instance, try http://www.jsoneditoronline.org.");
    }
  }

  template<typename T>
  jsonParser &to_json(const std::complex<T> &value, jsonParser &json) {
    json = jsonParser::object();
    json["real"] = value.real();
    json["imag"] = value.imag();
    return json;
  }

  template<typename T>
  void from_json(std::complex<T> &value, const jsonParser &json) {
    try {
      value = std::complex<T>(json["real"].get<T>(), json["imag"].get<T>());
    }
    catch(...) {
      throw;
    }
  }


  template<typename Key, typename T>
  jsonParser &to_json(const std::pair<Key, T> &value, jsonParser &json);

  template<typename Key, typename T>
  void from_json(std::pair<Key, T> &value, const jsonParser &json);

  template<typename ReturnType>
  struct jsonConstructor {

    static ReturnType from_json(const jsonParser &json) {
      return CASM::from_json<ReturnType>(json);
    }
  };


  template<typename T>
  T from_json(const jsonParser &json) {
    T value;
    from_json(value, json);
    return value;
  }


  boost::filesystem::path find_diff(const jsonParser &A, const jsonParser &B, boost::filesystem::path diff = boost::filesystem::path());

  boost::filesystem::path find_diff(const jsonParser &A, const jsonParser &B, double tol, boost::filesystem::path diff = boost::filesystem::path());


  template<bool IsConst>
  class jsonParserIterator {

  public:

    typedef std::forward_iterator_tag iterator_category;
    typedef typename std::conditional<IsConst, json_spirit::mObject::const_iterator, json_spirit::mObject::iterator>::type object_iterator;
    typedef typename std::conditional<IsConst, json_spirit::mArray::const_iterator, json_spirit::mArray::iterator>::type array_iterator;
    typedef int difference_type;
    typedef typename std::conditional<IsConst, const jsonParser, jsonParser>::type value_type;
    typedef value_type &reference;
    typedef value_type *pointer;


    jsonParserIterator() {}

    jsonParserIterator(const jsonParserIterator &iter)
      : parser(iter.parser), type(iter.type), obj_iter(iter.obj_iter), array_iter(iter.array_iter), val_iter(iter.val_iter) {
    }

    jsonParserIterator &operator=(jsonParserIterator iter) {
      swap(*this, iter);
      return *this;
    }

    jsonParserIterator(pointer j, const object_iterator &iter)
      : parser(j), type(json_spirit::obj_type), obj_iter(iter) {
    }

    jsonParserIterator(pointer j, const array_iterator &iter)
      : parser(j), type(json_spirit::array_type), array_iter(iter) {
    }

    jsonParserIterator(pointer j, const int &iter)
      : parser(j), type(json_spirit::null_type), val_iter(iter) {
    }

    reference operator*() {
      if(type == json_spirit::obj_type)
        return (reference) obj_iter->second;
      else if(type == json_spirit::array_type)
        return (reference) * array_iter;
      else
        return *parser;
    }

    pointer operator->() {
      if(type == json_spirit::obj_type)
        return (pointer) &obj_iter->second;
      else if(type == json_spirit::array_type)
        return (pointer) & (*array_iter);
      else
        return parser;
    }


    bool operator==(const jsonParserIterator &iter) {
      if(parser != iter.parser)
        return false;

      if(type == json_spirit::obj_type)
        return obj_iter == iter.obj_iter;
      else if(type == json_spirit::array_type)
        return array_iter == iter.array_iter;
      else
        return true;
    }

    bool operator!=(const jsonParserIterator &iter) {
      return !(*this == iter);
    }

    jsonParserIterator &operator++() {
      if(type == json_spirit::obj_type) {
        ++obj_iter;
        return *this;
      }
      else if(type == json_spirit::array_type) {
        ++array_iter;
        return *this;
      }
      else {
        ++val_iter;
        return *this;
      }
    }

    jsonParserIterator operator++(int) {

      jsonParserIterator cp(*this);

      if(type == json_spirit::obj_type) {
        ++obj_iter;
        return cp;
      }
      else if(type == json_spirit::array_type) {
        ++array_iter;
        return cp;
      }
      else {
        ++val_iter;
        return cp;
      }
    }

    jsonParserIterator &operator--() {
      if(type == json_spirit::obj_type) {
        --obj_iter;
        return *this;
      }
      else if(type == json_spirit::array_type) {
        --array_iter;
        return *this;
      }
      else {
        --val_iter;
        return *this;
      }
    }

    jsonParserIterator operator--(int) {

      jsonParserIterator cp(*this);

      if(type == json_spirit::obj_type) {
        --obj_iter;
        return cp;
      }
      else if(type == json_spirit::array_type) {
        --array_iter;
        return cp;
      }
      else {
        --val_iter;
        return cp;
      }
    }

    operator jsonParser::const_iterator() {
      if(type == json_spirit::obj_type)
        return jsonParser::const_iterator(parser, obj_iter);
      else if(type == json_spirit::array_type)
        return jsonParser::const_iterator(parser, array_iter);
      else
        return jsonParser::const_iterator(parser, val_iter);
    }

    std::string name() {
      if(type == json_spirit::obj_type)
        return obj_iter->first;
      else
        throw std::runtime_error("Calling 'name' on non-object jsonParserIterator");
    }

    friend void swap(jsonParserIterator &a, jsonParserIterator &b) {
      using std::swap;

      std::swap(a.parser, b.parser);
      swap(a.type, b.type);
      swap(a.obj_iter, b.obj_iter);
      swap(a.array_iter, b.array_iter);
      swap(a.val_iter, b.val_iter);
    }


  private:

    pointer parser;

    json_spirit::Value_type type;

    object_iterator obj_iter;

    array_iterator array_iter;

    int val_iter;

  };

  template<typename T>
  jsonParser &jsonParser::push_back(const T &value) {
    try {
      jsonParser json;
      get_array().push_back(to_json(value, json));
      return *this;
    }
    catch(...) {
      throw;
    }
  }

  template<typename T, typename...Args>
  T jsonParser::get(Args... args) const {
    return jsonConstructor<T>::from_json(*this, args...);
  }

  template<typename T, typename...Args>
  void jsonParser::get(T &t, Args... args) const {
    from_json(t, *this, args...);
  }


  template<typename T, typename...Args>
  bool jsonParser::get_if(T &t, const std::string &key, Args... args) const {
    if(find(key) != cend()) {
      from_json(t, (*this)[key], args...);
      return true;
    }
    return false;
  }

  template<typename T, typename...Args>
  bool jsonParser::get_else(T &t, const std::string &key, const T &default_value, Args... args) const {
    if(find(key) != cend()) {
      from_json(t, (*this)[key], args...);
      return true;
    }

    t = default_value;
    return false;
  }

  template <typename T>
  jsonParser &jsonParser::put(const T &value) {
    return to_json(value, *this);
  }

  template<typename Iterator>
  jsonParser &jsonParser::put_obj(Iterator begin,
                                  Iterator end) {
    *this = object();
    for(auto it = begin; it != end; ++it) {
      to_json(it->second, (*this)[it->first]);
    }
    return *this;
  }

  template<typename T>
  jsonParser &jsonParser::put_array(size_type N, const T &t) {
    *this = array();
    for(auto i = 0; i < N; ++i) {
      push_back(t);
    }
    return *this;
  }

  template<typename Iterator>
  jsonParser &jsonParser::put_array(
    Iterator begin,
    Iterator end,
    typename CASM_TMP::enable_if_iterator<Iterator>::type *) {

    *this = array();
    for(auto it = begin; it != end; ++it) {
      push_back(*it);
    }
    return *this;
  }

  template <typename T>
  jsonParser &jsonParser::operator=(const T &value) {
    return to_json(value, *this);
  }

  template<typename Key, typename T>
  jsonParser &to_json(const std::pair<Key, T> &value, jsonParser &json) {
    json = jsonParser::object();
    return json[value.first] = value.second;
  }

  template<typename Key, typename T>
  void from_json(std::pair<Key, T> &value, const jsonParser &json) {
    auto it = json.begin();
    value = std::make_pair<Key, T>(it.name(), *it);
  }

}

#endif