jsonParser.hh

Go to the documentation of this file.

#ifndef CASM_JSONPARSER_HH
#define CASM_JSONPARSER_HH
 
#include <complex>
#include <exception>
 
#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"
 
namespace boost {
namespace filesystem {
class path;
}
}  // namespace boost
 
namespace CASM {
 
namespace fs = boost::filesystem;
 
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);
  }
 
  struct as_array {};
 
  struct as_flattest {};
 
  // ---- 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_float() 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 size_type &element);
 
  const jsonParser &operator[](const size_type &element) const;
 
  jsonParser &at(const size_type &element);
 
  const jsonParser &at(const size_type &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;
 
  jsonParser::iterator find_at(const fs::path &path);
 
  jsonParser::const_iterator find_at(const fs::path &path) 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>
  T get_if_else(const std::string &key, const T &default_value,
                Args &&... args) const;
 
  template <typename T, typename... Args>
  bool get_else(T &t, const std::string &key, const T &default_value,
                Args &&... args) const;
 
  template <typename T, typename... Args>
  std::unique_ptr<T> make(Args &&... args) const;
 
  template <typename T, typename... Args>
  void make(std::unique_ptr<T> &ptr, Args &&... args) const;
 
  template <typename T, typename... Args>
  bool make_if(std::unique_ptr<T> &ptr, const std::string &key,
               Args &&... args) const;
 
  template <typename T, typename... Args>
  std::unique_ptr<T> make_optional(const std::string &key,
                                   Args &&... args) const;
 
  template <typename T, typename... Args>
  std::unique_ptr<T> make_if_else(const std::string &key,
                                  std::unique_ptr<T> default_value,
                                  Args &&... args) const;
 
  template <typename T, typename... Args>
  bool make_else(std::unique_ptr<T> &ptr, const std::string &key,
                 std::unique_ptr<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, typename... Args>
  jsonParser &push_back(const T &value, Args &&... args);
 
  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, typename... Args,
            typename CASM_TMP::enable_if_iterator<Iterator>::type * = nullptr>
  jsonParser &put_array(Iterator begin, Iterator end, Args &&... args);
 
  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);
 
  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 <typename T>
std::unique_ptr<T> make_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."));
  }
}
 
void to_json(fs::path file_path, jsonParser &json);
 
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 ValueType>
struct jsonMake {
  static std::unique_ptr<ValueType> make_from_json(const jsonParser &json) {
    return CASM::make_from_json<ValueType>(json);
  }
};
 
template <typename T>
T from_json(const jsonParser &json) {
  T value;
  from_json(value, json);
  return value;
}
 
template <typename T>
std::unique_ptr<T> make_from_json(const jsonParser &json) {
  return std::unique_ptr<T>(new T(from_json<T>(json)));
}
 
// /// Make from JSON for basic types
// template<typename T>
// void make_from_json(std::unique_ptr<T>& ptr, const jsonParser &json) {
//   ptr = jsonMake<T>::make_from_json(json);
// }
 
template <typename T, typename... Args>
void make_from_json(std::unique_ptr<T> &ptr, const jsonParser &json,
                    Args &&... args) {
  ptr = jsonMake<T>::make_from_json(json, std::forward<Args>(args)...);
}
 
fs::path find_diff(const jsonParser &A, const jsonParser &B);
 
fs::path find_diff(const jsonParser &A, const jsonParser &B, double tol);
 
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);
 
  jsonParserIterator &operator=(jsonParserIterator iter);
 
  jsonParserIterator(pointer j, const object_iterator &iter);
 
  jsonParserIterator(pointer j, const array_iterator &iter);
 
  jsonParserIterator(pointer j, const int &iter);
 
  reference operator*() const;
 
  pointer operator->() const;
 
  bool operator==(const jsonParserIterator &iter) const;
 
  bool is_end() const;
 
  bool operator!=(const jsonParserIterator &iter) const;
 
  jsonParserIterator &operator++();
 
  jsonParserIterator operator++(int);
 
  jsonParserIterator &operator--();
 
  jsonParserIterator operator--(int);
 
  operator jsonParser::const_iterator() const;
 
  std::string name() const;
 
  template <bool _IsConst>
  friend void swap(jsonParserIterator<_IsConst> &a,
                   jsonParserIterator<_IsConst> &b);
 
 private:
  pointer parser;
 
  json_spirit::Value_type type;
 
  object_iterator obj_iter;
 
  array_iterator array_iter;
 
  int val_iter;
};
 
template <typename T, typename... Args>
jsonParser &jsonParser::push_back(const T &value, Args &&... args) {
  try {
    jsonParser json;
    get_array().push_back(to_json(value, json, std::forward<Args>(args)...));
    return *this;
  } catch (...) {
    throw;
  }
}
 
template <typename T, typename... Args>
T jsonParser::get(Args &&... args) const {
  return jsonConstructor<T>::from_json(*this, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
void jsonParser::get(T &t, Args &&... args) const {
  from_json(t, *this, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
bool jsonParser::get_if(T &t, const std::string &key, Args &&... args) const {
  auto it = find(key);
  if (it != cend()) {
    it->get(t, std::forward<Args>(args)...);
    return true;
  }
  return false;
}
 
template <typename T, typename... Args>
T jsonParser::get_if_else(const std::string &key, const T &default_value,
                          Args &&... args) const {
  auto it = find(key);
  if (it != end()) {
    return it->get<T>(std::forward<Args>(args)...);
  } else {
    return default_value;
  }
}
 
template <typename T, typename... Args>
bool jsonParser::get_else(T &t, const std::string &key, const T &default_value,
                          Args &&... args) const {
  auto it = find(key);
  if (it != cend()) {
    it->get(t, std::forward<Args>(args)...);
    return true;
  }
 
  t = default_value;
  return false;
}
 
template <typename T, typename... Args>
std::unique_ptr<T> jsonParser::make(Args &&... args) const {
  return jsonMake<T>::make_from_json(*this, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
void jsonParser::make(std::unique_ptr<T> &ptr, Args &&... args) const {
  make_from_json(ptr, *this, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
bool jsonParser::make_if(std::unique_ptr<T> &ptr, const std::string &key,
                         Args &&... args) const {
  auto it = find(key);
  if (it != cend()) {
    it->make(ptr, std::forward<Args>(args)...);
    return true;
  }
  return false;
}
 
template <typename T, typename... Args>
std::unique_ptr<T> jsonParser::make_optional(const std::string &key,
                                             Args &&... args) const {
  auto it = find(key);
  if (it != cend()) {
    return it->make(std::forward<Args>(args)...);
  }
  return std::unique_ptr<T>();
}
 
template <typename T, typename... Args>
std::unique_ptr<T> jsonParser::make_if_else(const std::string &key,
                                            std::unique_ptr<T> default_value,
                                            Args &&... args) const {
  auto it = find(key);
  if (it != cend()) {
    return it->make(std::forward<Args>(args)...);
  }
  return std::move(default_value);
}
 
template <typename T, typename... Args>
bool jsonParser::make_else(std::unique_ptr<T> &ptr, const std::string &key,
                           std::unique_ptr<T> default_value,
                           Args &&... args) const {
  auto it = find(key);
  if (it != cend()) {
    it->make(ptr, std::forward<Args>(args)...);
    return true;
  }
 
  ptr = std::move(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, typename... Args,
          typename CASM_TMP::enable_if_iterator<Iterator>::type *>
jsonParser &jsonParser::put_array(Iterator begin, Iterator end,
                                  Args &&... args) {
  *this = array();
  for (auto it = begin; it != end; ++it) {
    push_back(*it, std::forward<Args>(args)...);
  }
  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);
}
 
template <typename T>
jsonParser json_pair(const std::string &key, const T &value) {
  jsonParser tjson;
  tjson[key] = value;
  return tjson;
}
 
}  // namespace CASM
 
#endif