jsonserial.hpp

// JSonSerial2: C++ Object Serialization in JSON
// See: https://www.telecom-paris.fr/~elc/software/
//
// Copyright 2020 Eric Lecolinet (eric.lecolinet@gmail.com)
//
// 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 jsonserial_hpp
#define jsonserial_hpp
#include <cstdlib>
#include <cstring>
#include <locale>
#include <memory>
#include <string>
#include <type_traits>
#include <functional>
#include <typeinfo>
#include <typeindex>
#include <utility>
#include <iostream>
#include <fstream>
#include <sstream>
#include <list>
#include <unordered_map>
namespace jsonserial {

class JSonSerial;
class JSonClasses;
using JString = std::string;
using JKString = const std::string;

// true if T is a custom primitive type
template <class T> struct is_primitive : std::false_type {};

// true if T is a std::array (not to be confused with C-style bracketed arrays).
template <class T> struct is_std_array : std::false_type {};

// true if T is a std::list.
template <class T> struct is_std_list : std::false_type {};

// true if T is a std::forward_list.
template <class T> struct is_std_forward_list : std::false_type {};

// true if T is a std::map or std::unordered_map.
template <class T> struct is_std_map : std::false_type {};

// true if T is a std::set or std::unordered_set.
template <class T> struct is_std_set : std::false_type {};

// true if T is a std::vector or std::deque.
template <class T> struct is_std_vector : std::false_type {};

// true if T is formatted as a JSON array (ie with brackets).
template <class T> struct has_array_format {
  static constexpr bool value = is_std_array<T>::value
  || is_std_list<T>::value
  || is_std_forward_list<T>::value
  || is_std_vector<T>::value
  || is_std_set<T>::value;
};

// true if T is a smart pointer (ie std::shared_ptr or std::unique_ptr).
template <class T> struct is_owning_ptr : std::false_type {};
template <class T> struct is_owning_ptr<std::shared_ptr<T>> : std::true_type {};
template <class T> struct is_owning_ptr<std::unique_ptr<T>> : std::true_type {};

template <class T> struct is_weak_ptr : std::false_type {};
template <class T> struct is_weak_ptr<std::weak_ptr<T>> : std::true_type {};

template <class T> struct is_smart_ptr {
  static constexpr bool value = is_owning_ptr<T>::value || is_weak_ptr<T>::value;
};

// true if T is a user class (needs to be declared by calling JSonClasses::add())
template <class T> struct is_user_class {
  static constexpr bool value = std::is_class<T>::value
  && !std::is_base_of<JString, T>::value
  && !is_primitive<T>::value
  && !is_smart_ptr<T>::value
  && !has_array_format<T>::value
  && !is_std_map<T>::value;
};

// Type of a pointer to T (takes into account smart pointers),
template<class T, class Enable = void> struct makeptr {};

template<class T> struct makeptr<T, typename std::enable_if<is_smart_ptr<T>::value>::type> {
  typedef typename T::element_type* type;
};

template<class T> struct makeptr<T, typename std::enable_if<!is_smart_ptr<T>::value>::type> {
  typedef typename std::conditional<std::is_pointer<T>::value,T, T*>::type type;
};

// Type of a pointer to a JSON array or C-array with brackets,
template<class X, class Enable = void> struct makearrayptr {};

template<class X> struct makearrayptr<X, typename std::enable_if<std::is_array<X>::value>::type> {
  typedef typename makeptr<typename std::remove_extent<X>::type>::type type;
};

template<class X> struct makearrayptr<X, typename std::enable_if<has_array_format<X>::value>::type> {
  typedef typename makeptr<typename X::value_type>::type type;
};

struct JObjectPtr {void *raw_{}, *shared_{}; bool init_{};};

class JSonError {
public:
  enum Type {
    OK, CantReadFile, CantWriteFile, NoData, PrematureEOF, InvalidCharacter,
    ExpectingComma, ExpectingDelimiter, ExpectingBrace, ExpectingBracket,
    ExpectingPairOrBrace, ExpectingValueOrBracket, ExpectingString,
    UnknownClass, UnknownSuperclass, RedefinedClass, RedefinedSuperclass,
    UnknownMember, RedefinedMember, AbstractClass, CantCreateObject, CantAddToArray,
    InvalidValue, InvalidID, WrongKeyword, UnexpectedNull, ErrorCount
  };

  using Handler = std::function<void(JSonError const&)>;

  JSonError(Type type, JKString& arg, JKString& fname, size_t line)
  : type(type), arg(arg), fname(fname), line(line) {}

  // Prints an error on out.
  void print(std::ostream& out) const {
    out << "Error ";
    if (line > 0) out << "at or before line " << line;
    if (!fname.empty()) out << "in '" << fname << "'";
    out << ": "<< getErrorMessage(type);
    if (!arg.empty()) out << " " << arg;
    out << std::endl;
  }

  static const char* getErrorMessage(Type type) {
    constexpr static const char* _errors[ErrorCount] {
      "OK",
      "can't read file",
      "can't write file",
      "no data",
      "premature end of file",
      "invalid character in string: ",
      "expecting ,",
      "expecting , or } or ]",
      "expecting {",
      "expecting [",
      "expecting } or name:value pair",
      "expecting ] or value",
      "expecting a quoted name:",
      "unknown class",
      "unknown superclass",
      "class already declared",
      "already declared as a superclass",
      "unknown member",
      "class member already declared",
      "can't instantiate abstract class",
      "can't create object",
      "C-style array too small",
      "invalid value:",
      "expecting ID after @",
      "expecting @id or @class",
      "internal error: unexpected null pointer"
    };
    if (type >= ErrorCount) return "Unknown error";
    else return _errors[type];
  }

  Type type;
  JString arg, fname;
  size_t line;
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

class JSonClass {
public:
  struct Creator {
    virtual void* create() = 0;
    virtual ~Creator() = default;
  };
  virtual ~JSonClass() = default;
  virtual void* create() const = 0;
  virtual JKString& className() const = 0;
  virtual bool readMember(JSonSerial&, void* obj, JKString& name, JKString& value) const = 0;
  virtual void writeMembers(JSonSerial&, const void* obj) const = 0;
  virtual void doPostRead(void* obj) const = 0;
  virtual void doPostWrite(const void* obj) const = 0;
};

struct JSonArray {
  virtual ~JSonArray() = default;
  virtual void add(JSonSerial&, JSonClass::Creator*, JKString& s) = 0;
  virtual void end(JSonSerial&) {}
};
template <class T, class Enable = void> struct JSonArrayImpl : public JSonArray {};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

template <class C> class JSonUserClass : public JSonClass {
public:
  template <typename Super> JSonUserClass& extends();

  template <typename Var>
  JSonUserClass& addMember(JKString& name, Var& var);

  template <typename Var, typename T>
  JSonUserClass& addMember(JKString& name, Var T::* var);

  template <typename Set, typename Get>
  JSonUserClass& addMember(JKString& name, void (C::*setter)(Set), Get(C::*getter)() const);

  JSonUserClass& addMember(JKString& name,
                           std::function<void(C&, JSonSerial&, JKString& value)> read,
                           std::function<void(const C&, JSonSerial&)> write);

  template <typename Var>
  JSonUserClass& addMember(JKString& name, Var C::* var,
                           std::function<typename makeptr<Var>::type(C&)> creator);

  template <typename Var>
  JSonUserClass& addMember(JKString& name, Var C::* var,
                           std::function<typename makearrayptr<Var>::type(C&)> element_creator);

  JSonUserClass& postRead(std::function<void(C&)> fun) {postread_ = fun; return *this;}

  JSonUserClass& postWrite(std::function<void(const C&)> fun) {postwrite_ = fun; return *this;}

  JKString& className() const override {return classname_;}

  class Member {
  public:
    Member(JKString& name) : name_(name) {}
    virtual ~Member() = default;
    JKString& name() const {return name_;}
    virtual bool isCustom() const {return false;}
    virtual void read(JSonSerial&, C& object, JKString& value) = 0;
    virtual void write(JSonSerial&, const C& object) = 0;
  protected:
    JKString name_;
  };

  JSonUserClass(JSonClasses& classes, JKString& classname, std::function<C*()> creator)
  : classes_(classes), classname_(classname), creator_(creator) {}
  virtual ~JSonUserClass() {for (auto& it : members_) delete it;}

  void* create() const override {return creator_ ? (creator_)() : nullptr;}
  void addMember(JKString& varname, Member*);
  Member* getMember(JKString& varname) const;
  bool readMember(JSonSerial&, void* obj, JKString& name, JKString& val) const override;
  void writeMembers(JSonSerial&, const void* obj) const override;
  void doPostRead(void* obj) const override;
  void doPostWrite(const void* obj) const override;

  struct Superclass {
    const JSonClass* super_;
    void* (*upcast_)(void*);
  };

  struct Superclasses : public std::list<Superclass> {
    template <class S> void add(const JSonClass* c) {this->push_back(Superclass{c, upcast<S>});}
    template <class S> static void* upcast(void* obj) {return dynamic_cast<S*>(static_cast<C*>(obj));}
  };

  JSonClasses& classes_;
  JKString classname_;
  Superclasses superclasses_;
  std::function<C*()> creator_{};
  std::list<Member*> members_;
  std::unordered_map<std::string, Member*> membermap_;
  std::function<void(C&)> postread_{};
  std::function<void(const C&)> postwrite_{};
};


// JSonClass for maps.
template <class C> class JMapClass : public JSonClass {
public:
  JKString& className() const override {static JString s("std::map"); return s;}
  void* create() const override {return new C;}
  bool readMember(JSonSerial&, void* obj, JKString& name, JKString& value) const override;
  void writeMembers(JSonSerial&, const void* obj) const override;
  void doPostRead(void*) const override {}
  void doPostWrite(const void*) const override {}
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

class JSonClasses {
public:
  JSonClasses(JSonError::Handler handler = {}) : errhandler_(handler) {}

  template <class T>
  JSonUserClass<T>& addClass(JKString& classname) {
    struct Helper {static T* create() {return new T;} ;};
    return addClass<T>(classname, Helper::create);
  }

  template <class T>
  JSonUserClass<T>& addClass(JKString& classname, std::function<T*()> creator);

  void error(JSonError::Type type, JKString& arg, JKString& name) {
    JSonError e(type, arg, name, 0);
    if (errhandler_) errhandler_(e); else e.print(std::cout);
  }

  const JSonClass* getClass(JKString& classname) const {
    auto it = classnames_.find(classname);
    return (it == classnames_.end()) ? nullptr : it->second;
  }

  const JSonClass* getClass(const std::type_info& tinfo) const {
    auto it = classindexes_.find(std::type_index(tinfo));
    return (it == classindexes_.end()) ? nullptr : it->second;
  }

  bool empty() const {return classnames_.empty();}

  ~JSonClasses() {
    for (auto& it : classnames_) delete it.second;
  }

private:
  JSonError::Handler errhandler_{};
  std::unordered_map<std::type_index, JSonClass*> classindexes_;
  std::unordered_map<std::string, JSonClass*> classnames_;
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

class JSonSerial {
public:
  JSonSerial(JSonClasses const& classes, JSonError::Handler handler = {})
  : classes_(&classes), errhandler_(handler) {}

  JSonSerial(JSonClasses const* classes, JSonError::Handler handler = {})
  : classes_(classes), errhandler_(handler) {}

  template <class T>
  bool read(T& object, JKString& filename) {
    std::ifstream input(filename);
    if (input) return read(object, input, filename, 1);
    else {
      reset(filename, 0, nullptr, nullptr, false);
      JSonError e(JSonError::CantReadFile, "", filename, 0);
      doError(e);
      return false;
    }
  }

  template <class T>
  bool read(T& object, std::istream& in,
            JKString& name = "", size_t linenbr = 1) {
    try {
      reset(name, linenbr, &in, nullptr, false);
      JString keyword, dump;
      bool found1, found2;
      readLine(keyword, dump, found1, found2, true);
      if (found1) readValue(*this, object, keyword); else error(JSonError::NoData);
    }
    catch (JSonError& e) {
      doError(e);
      return false;
    }
    return true;
  }

  template <class T>
  bool write(const T& object, JKString& filename, bool cyclic_graph) {
    std::ofstream output(filename);
    if (output) return write(object, output, cyclic_graph, filename, 1);
    else {
      reset(filename, 0, nullptr, nullptr, false);
      JSonError e(JSonError::CantWriteFile, "", filename, 0);
      doError(e);
      return false;
    }
  }

  template <class T>
  bool write(const T& object, std::ostream& out, bool cyclic_graph,
             JKString& name = "", size_t linenbr = 1) {
    try {
      reset(name, linenbr, nullptr, &out, cyclic_graph);
      writeValue(object);
      *out_ << "\n" << std::endl;
    }
    catch (JSonError& e) {
      doError(e);
      return false;
    }
    return true;
  }

  enum JSyntax {
    Strict=0, Comments=1, NoQuotes=2, NoCommas=4, Newlines=8,
    Relaxed=(Comments|NoQuotes|NoCommas|Newlines)
  };

  void setSyntax(unsigned int mode) {allow_ = mode;}
  unsigned int getSyntax() const {return allow_;}

  void setIndent(char tabchar, unsigned int tabcount) {tabchar_ = tabchar; indent_ = tabcount;}
  void getIndent(char& tabchar, unsigned int& tabcount) const {tabchar = tabchar_; tabcount = indent_;}

  template <class T>
  void readMember(T& variable, JKString& str) {
    readValue(*this, variable, str);
  }

  template <class T>
  void writeMember(const T& variable) {
    writeTabs(); *out_ << '"' << token1_ << "\": ";
    writeValue(variable);
  }

  void error(JSonError::Type type, JKString& arg = "") {
    throw JSonError(type, arg, fname_, lineno_);
  }

  void doError(JSonError e) {
    if (errhandler_) errhandler_(e); else e.print(std::cout);
  }

  // throws if class not found.
  const JSonClass* getCheckedClass(const std::type_info& tinfo) {
    const JSonClass* cl = classes_->getClass(tinfo);
    if (!cl) error(JSonError::UnknownClass, tinfo.name());
    return cl;
  }

  // writes a char, a bool or a string
  void writeValue(char c) {*out_ << '\"' << c << '\"'; needcomma_ = true;}
  void writeValue(bool b) {*out_ << (b ? "true" : "false"); needcomma_ = true;}
  void writeValue(JKString& s) {writeString(s.c_str(), false);}
  void writeValue(char* s) {writeString(s, true);}
  void writeValue(const char* s) {writeString(s, true);}

  // writes anything except a string or a bool.
  template <class T> void writeValue(const T& val) {writeValue2<T>(val); needcomma_ = true;}

  // writes a raw pointer (note: is_pointer differentiates from is_array).
  template <class T>
  void writeValue2(const typename std::enable_if<std::is_pointer<T>::value,T>::type & ptr) {
    if (!ptr) *out_ << "null"; else writeValue(*ptr);
  }

  // writes a smart pointer.
  template <class T>
  void writeValue2(const typename std::enable_if<is_owning_ptr<T>::value,T>::type & ptr) {
    if (!ptr) *out_ << "null"; else writeValue(*ptr);
  }

  // writes a weak pointer.
  template <class T>
  void writeValue2(const typename std::enable_if<is_weak_ptr<T>::value,T>::type & ptr) {
    auto p = ptr.lock();
    if (!p) *out_ << "null"; else writeValue(*p);
  }

  // writes a number.
  template <class T>
  void writeValue2(const typename std::enable_if<std::is_arithmetic<T>::value,T>::type & number) {
    *out_ << number;
  }

  // writes an enum.
  template <class T>
  void writeValue2(const typename std::enable_if<std::is_enum<T>::value,T>::type & val) {
    *out_ << int(val);
  }

  // writes a custom primitive type.
  template <class T>
  void writeValue2(const typename std::enable_if<is_primitive<T>::value,T>::type & val) {
    *out_ << val;
  }

  // writes a map.
  template <class T>
  void writeValue2(const typename std::enable_if<is_std_map<T>::value,T>::type & obj) {
    JMapClass<T> cl; writeObject(cl, false, &obj);
  }

  // writes an array_style C++ container
  template <class T>
  void writeValue2(const typename std::enable_if<has_array_format<T>::value,T>::type & cont) {
    if (cont.empty()) *out_ << "[]"; else writeArray(cont);
  }

  // writes a C-array.
  template <class T>
  void writeValue2(const typename std::enable_if<std::is_array<T>::value,T>::type & carray) {
    if (std::extent<T>::value == 0) *out_ << "[]"; else writeArray(carray);
  }

  // writes a plain user object.
  template <class T>
  void writeValue2(const typename std::enable_if<is_user_class<T>::value,T>::type & obj) {
    const JSonClass* cl = classes_->getClass(typeid(obj));
    if (!cl) error(JSonError::UnknownClass, typeid(obj).name());
    writeObject(*cl, (typeid(obj) != typeid(T)), &obj);
  }

  // writes a user object pointee.
  void writeObject(const JSonClass& cl, bool is_derived_class, const void* obj) {
    if (shareobj_) {
      auto it = object_to_id_.find(obj);
      if (it != object_to_id_.end()) {*out_ << "\"@"<< it->second <<'"'; return;}
      else object_to_id_[obj] = ++current_object_id_;
    }
    needcomma_ = false;
    *out_ << "{\n";
    addTab();
    if (is_derived_class) {   // polymorphism
      writeTabs(); *out_ << "\"@class\": \"" << cl.className() << "\",\n";
    }
    if (shareobj_) {
      writeTabs(); *out_ << "\"@id\": \"" << current_object_id_ << "\",\n";
    }
    cl.writeMembers(*this, obj);
    removeTab();
    *out_ << "\n"; writeTabs(); *out_ << "}";
    needcomma_ = true;
    cl.doPostWrite(obj);  // end of the object
  }

  // writes a C++ container or a C-array.
  template <class T> void writeArray(const T & array) {
    needcomma_ = false;
    *out_ << "[\n";
    addTab();
    for (auto& it : array) {
      if (needcomma_) *out_ << ",\n";
      writeTabs();
      needcomma_ = false;
      writeValue(it);
    }
    removeTab();
    *out_ << "\n"; writeTabs(); *out_ << "]";
  }

  // writes a string.
  void writeString(const char* s, bool is_cstring) {
    if (!s) {*out_ << (is_cstring ? "null" : "\"\"");}
    else {
      out_->put('"');
      for (; *s != 0; ++s) {
        switch (*s) {
          case '"': out_->put('\\'); out_->put('"'); break;
          case '\\': out_->put('\\'); out_->put('\\'); break;
          case '\b': out_->put('\\'); out_->put('b'); break;
          case '\f': out_->put('\\'); out_->put('f'); break;
          case '\n': out_->put('\\'); out_->put('n'); break;
          case '\r': out_->put('\\'); out_->put('r'); break;
          case '\t': out_->put('\\'); out_->put('t'); break;
          default: out_->put(*s);
        }
      }
      out_->put('"');
    }
    needcomma_ = true;
  }

  void readLine(JString& token1, JString& token2, bool& found1, bool& found2, bool inObj) {
    token1.clear();
    token2.clear();
    token1_.clear();
    token2_.clear();
    found1 = found2 = false;
    enum {
      Begin, InQuotedToken1, InUnquotedToken1, AfterToken1, AfterComa,
      InQuotedToken2, InUnquotedToken2, AfterToken2, Comment, LineComment
    }
    part{Begin}, lastPart{Begin};
    char c = 0;

    while (true) {
      if (!in_->get(c)) {
        if (!token1_.empty()) {token1 = token1_; checkValue(token1,inObj);}
        return;
      }

      if (c == '\n')
        lineno_++;
      else if (::iscntrl(c) && !::isspace(c))
        goto INVALID_CHAR;
      else if ((allow_&Comments) && part!=InQuotedToken1 && part!=InQuotedToken2) {
        if (part != Comment && c == '/' && in_->peek() == '/') {
          if (part != LineComment) {lastPart = part; part = LineComment;}
        }
        else if (part != LineComment && c == '/' && in_->peek() == '*') {
          if (part != Comment) {in_->get(c); lastPart = part; part = Comment;}
        }
      }
      switch (part) {
        case Begin:
          if (c == '"') {found1 = true; part = InQuotedToken1;}
          else if (c == '{' || c == '[') {found1 = true; token1 = c; return;}
          else if (!::isspace(c)) {found1 = true; token1_ += c; part = InUnquotedToken1;}
          break;
        case InQuotedToken1:
          if (c == '"') {token1 = token1_; part = AfterToken1;}
          else if (c == '\\') readEscape(token1_);
          else if (::iscntrl(c) && (!(allow_&Newlines) || !::isspace(c))) goto INVALID_CHAR;
          else token1_ += c;
          break;
        case InUnquotedToken1:
          if (c == ',' || ((allow_&NoCommas) && c == '\n')) {token1 = token1_; checkValue(token1,inObj); return;}
          else if (c == '}' || c == ']')
          {in_->putback(c); token1 = token1_; checkValue(token1,inObj); return;}
          else if (c == ':' && inObj) {token1 = token1_; checkValue(token1,inObj); part = AfterComa;}
          else if (c == '\\') readEscape(token1_);
          else token1_ += c;
          break;
        case AfterToken1:
          if (c == ',' || ((allow_&NoCommas) && c == '\n')) return;
          else if (c == '}' || c == ']') {in_->putback(c); return;}
          else if (c == ':' && inObj) part = AfterComa;
          else if (!::isspace(c)) {error(JSonError::ExpectingComma); return;}
          break;
        case AfterComa:
          if (c == '"') {
            found2 = true;
            if (in_->peek() != '"') part = InQuotedToken2;
            else {
              in_->get(c);
              if (in_->peek() != '"') {token2 = ""; part = AfterToken2;}
              else {in_->get(c); part = InQuotedToken2; in_multiquotes_ = true;}
            }
          }
          else if (c == '{' || c == '[') {found2 = true; token2 = c; return;}
          else if (!::isspace(c)) {found2 = true; token2_ += c; part = InUnquotedToken2;}
          break;
        case InQuotedToken2:
          if (c == '"') {
            if (!in_multiquotes_) {token2 = token2_; part = AfterToken2;}
            else if (in_->peek() != '"') token2_ += '"';
            else {
              in_->get(c);
              if (in_->peek() != '"') token2_ += "\"\"";
              else {
                in_->get(c); token2 = token2_; part = AfterToken2; in_multiquotes_ = false;
              }
            }
          }
          else if (in_multiquotes_ && ::isspace(c)) token2_ += c;
          else if (c == '\\') readEscape(token2_);
          else if (::iscntrl(c) && (!(allow_&Newlines) || !::isspace(c))) goto INVALID_CHAR;
          else token2_ += c;
          break;
        case InUnquotedToken2:
          if (c == ',' || ((allow_&NoCommas) && c == '\n')) {token2 = token2_; checkValue(token2,false); return;}
          else if (c == '}' || c == ']') {in_->putback(c); token2 = token2_; checkValue(token2,false); return;}
          else if (c == '\\') readEscape(token2_);
          else token2_ += c;
          break;
        case AfterToken2:
          if (c == ',' || ((allow_&NoCommas) && c == '\n')) return;
          else if (c == '}' || c == ']') {in_->putback(c); return;}
          else if (!::isspace(c)) {error(JSonError::ExpectingDelimiter); return;}
          break;
        case LineComment:
          if ((allow_&Comments) && c == '\n') part = lastPart;
          break;
        case Comment:
          if ((allow_&Comments) && (c == '*' && in_->peek() == '/')) {in_->get(c); part = lastPart;}
          break;
      }
    }
    return;
  INVALID_CHAR:
    JString msg;
    if (c=='\n') msg="newline "; else if (c=='\r') msg="CR "; else if (c=='\t') msg="tab ";
    error(JSonError::InvalidCharacter, msg + "(code: "+std::to_string(int(c))+")");
  }

  void readEscape(JString& token) {
    int c = in_->get();
    switch (c) {
      case '"': token += '"'; break;
      case '\\': token += '\\'; break;
      case '/': token += '/'; break;
      case 'b': token += '\b'; break;
      case 'f': token += '\f'; break;
      case 'n': token += '\n'; break;
      case 'r': token += '\r'; break;
      case 't': token += '\t'; break;
        //case 'u': utf16_to_utf8(token); break; TODO
      default: token += c; break;
    }
  }

  bool isNumber(JKString& token) {
    if (token.empty()) return false;
    bool dotfound{false}, expfound{false};
    const char *p = token.c_str();
    if (*p == '-') ++p;
    for (; *p != 0; ++p)
    if (!::isdigit(*p)) {
      if (*p=='.') {if (dotfound) return false; else dotfound = true;}
      else if (*p=='e' || *p=='E') {
        if (expfound) return false; else expfound = true;
        if (*(p+1)=='+' || *(p+1)=='-') ++p;
      }
      else return false;
    }
    return true;
  }

  void checkValue(JString& token, bool objName) {
    if (!token.empty()) {   // trimRight
      const char *s = token.c_str(), *end = s + token.length()-1;
      while (end >= s && ::isspace(*end)) --end;
      if (end >= s) token.assign(s, end-s+1);
    }
    if (objName) {
      if ((allow_&NoQuotes) || token[0]=='}' || token[0]==']') return;
      else error(JSonError::ExpectingString, token);
    }
    else if ((allow_&NoQuotes) || token.empty()
             || token[0]=='}' || token[0]==']' || token=="true" || token=="false" || token=="null"
             || isNumber(token))
      return;
    else error(JSonError::InvalidValue, token+" (should be quoted)");
  }

  void reset(JKString& fname, size_t lineno,
             std::istream *in, std::ostream *out, bool shareobj) {
    in_ = in;
    out_ = out;
    if (in_) in_->imbue(locale_);
    if (out_) out_->imbue(locale_);
    fname_ = fname;
    lineno_ = lineno;
    needcomma_ = false;
    shareobj_ = shareobj;
    level_ = 0;
    token1_.reserve(50);
    token2_.reserve(50);
    in_multiquotes_ = false;
    tabs_.assign(40, tabchar_);
    object_to_id_.clear();
    id_to_object_.clear();
    current_object_id_ = 0;
  }

  void addTab() {if (++level_*indent_ >= tabs_.size()) tabs_.resize(tabs_.size() + 20, tabchar_);}
  void removeTab() {if (--level_ < 0) level_ = 0;}
  void writeTabs() {out_->write(tabs_.data(), level_*indent_);}

  JSonClasses const* classes_{};
  //std::locale locale_{std::locale::classic()};
  std::locale locale_{"en_US.UTF-8"};
  std::istream *in_{};
  std::ostream *out_{};
  unsigned char allow_{Comments};
  bool needcomma_{}, in_multiquotes_{}, shareobj_{};
  size_t lineno_{0};
  unsigned int indent_{2};
  int level_{0};
  char tabchar_{' '};
  JString fname_, tabs_, token1_, token2_;
  unsigned long current_object_id_{0};
  std::unordered_map<const void*, unsigned long> object_to_id_;
  std::unordered_map<unsigned long, JObjectPtr> id_to_object_;
  JSonError::Handler errhandler_{};
};


inline void* readObject(JSonSerial& js,
                        const JSonClass* objclass, const JSonClass* pointerclass,
                        JObjectPtr*& jsp, JSonClass::Creator* cr, void* obj, JKString& s);

// reads a non-object pointee pointed by a unique_ptr
template <class E>
inline void readPointee2(JSonSerial& js,
                         typename std::enable_if<!is_user_class<E>::value,std::unique_ptr<E>>::type & ptr,
                         JObjectPtr *&, JSonClass::Creator*, JKString& s) {
  ptr.reset(new E{});
  readValue(js, *ptr, s);
}

// reads a user object pointee pointed by a unique_ptr
template <class E>
inline void readPointee2(JSonSerial& js,
                         typename std::enable_if<is_user_class<E>::value,std::unique_ptr<E>>::type & ptr,
                         JObjectPtr *& objptr, JSonClass::Creator* cr, JKString& s) {
  ptr.reset(static_cast<E*>(readObject(js, nullptr, js.getCheckedClass(typeid(E)),
                                       objptr, cr, nullptr, s)));
}

// read non-object pointee pointed by shared_ptr
template <class E>
inline void readPointee2(JSonSerial& js,
                         typename std::enable_if<!is_user_class<E>::value,std::shared_ptr<E>>::type & ptr,
                         JObjectPtr *&, JSonClass::Creator*, JKString& s) {
  ptr.reset(new E{});
  readValue(js,*ptr, s);
}

// read a user object pointee pointed by shared_ptr
template <class E>
inline void readPointee2(JSonSerial& js,
                         typename std::enable_if<is_user_class<E>::value,std::shared_ptr<E>>::type & ptr,
                         JObjectPtr *& objptr, JSonClass::Creator* cr, JKString& s) {
  E* p = static_cast<E*>(readObject(js, nullptr, js.getCheckedClass(typeid(E)),
                                    objptr, cr, nullptr, s));
  if (!objptr) ptr.reset(p);
  else if (objptr->shared_) { // smart_ptr already init
    objptr->init_ = false;
    ptr = *static_cast<std::shared_ptr<E>*>(objptr->shared_);
  }
  else {
    ptr.reset(p);
    objptr->shared_ = &ptr;  // init smart_ptr
    objptr->init_ = true;
  }
}

// reads a non-object pointee pointed by a weak_ptr
template <class E>
inline void readPointee2(JSonSerial& js,
                         typename std::enable_if<!is_user_class<E>::value,std::weak_ptr<E>>::type & ptr,
                         JObjectPtr *&, JSonClass::Creator*, JKString& s) {
  using SHT = decltype(ptr.lock());
  SHT* shp = new SHT();   // !!!!!
  shp->reset(new E{});
  readValue(js, **shp, s);
  ptr = *shp;
}

// reads a user object pointee pointed by a weak_ptr
template <class T>
inline void readPointee2(JSonSerial& js,
                         typename std::enable_if<is_user_class<T>::value,std::weak_ptr<T>>::type & ptr,
                         JObjectPtr *& objptr, JSonClass::Creator* cr, JKString& s) {
  using SHT = decltype(ptr.lock());
  SHT* shp = new SHT();   // !!!!!
  T* p = static_cast<T*>(readObject(js, nullptr, js.getCheckedClass(typeid(T)),
                                    objptr, cr, nullptr, s));
  if (!objptr) shp->reset(p);
  else if (objptr->shared_) { // smart_ptr already init
    objptr->init_ = false;
    *shp = *static_cast<std::shared_ptr<T>*>(objptr->shared_);
  }
  else {
    shp->reset(p);
    objptr->shared_ = &ptr;  // init smart_ptr
    objptr->init_ = true;
  }
  ptr = *shp;
}

// reads a non-object pointed by a raw ptr
template <class T>
inline void readPointee(JSonSerial& js,
                        typename std::enable_if<!is_user_class<typename std::remove_reference<T>::type>::value,T>::type *& ptr,
                        JObjectPtr *&, JSonClass::Creator*, JKString& s) {
  ptr = new T{};
  readValue(js, *ptr, s);
}

// reads a user object pointed by a raw ptr
template <class T>
inline void readPointee(JSonSerial& js,
                        typename std::enable_if<is_user_class<typename std::remove_reference<T>::type>::value,T>::type *& ptr,
                        JObjectPtr *& objptr, JSonClass::Creator * cr, JKString& s) {
  ptr = static_cast<T*>(readObject(js, nullptr, js.getCheckedClass(typeid(T)),
                                   objptr, cr, nullptr, s));
}

// reads a pointee pointed by a smart pointer
template <class T>
inline void readPointee(JSonSerial& js,
                        typename std::enable_if<is_smart_ptr<T>::value,T>::type & ptr,
                        JObjectPtr *& objptr, JSonClass::Creator* cr, JKString& s) {
  readPointee2<typename T::element_type>(js, ptr, objptr, cr, s);
}

// reads a smart pointer.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<is_smart_ptr<T>::value,T>::type & ptr,
                       JKString& s) {
  JObjectPtr* objptr{}; ptr.reset();
  if (s != "null") readPointee<T>(js, ptr, objptr, nullptr, s);
}

// reads a number of another type than int, long, etc.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<std::is_arithmetic<T>::value,T>::type & val,
                       JKString& s) {
  std::istringstream ss(s);
  ss.imbue(js.locale_);
  ss >> val;
}

// reads an enum.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<std::is_enum<T>::value,T>::type & val,
                       JKString& s) {
  val = T(std::stoi(s));
}

// reads a custom primitive type.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<is_primitive<T>::value,T>::type & val,
                       JKString& s) {
  val = s;
}

// reads a user object.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<is_user_class<T>::value,T>::type & obj,
                       JKString& s) {
  const JSonClass* wanted_class = js.getCheckedClass(typeid(obj));
  JObjectPtr* objptr{};
  readObject(js, wanted_class, wanted_class, objptr, nullptr, &obj, s);
}

// reads a std::map.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<is_std_map<T>::value,T>::type & obj,
                       JKString& s) {
  JMapClass<T> wanted_class; JObjectPtr* objptr{};
  readObject(js, &wanted_class, &wanted_class, objptr, nullptr, &obj, s);
}

// reads a C-array with brackets.
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<std::is_array<T>::value,T>::type & array,
                       JKString& s) {
  JSonArrayImpl<T> a(array); readArray(js, a, nullptr, s);
}

// reads a JSON array container (eg std::list, std::vector).
template <class T>
inline void readValue2(JSonSerial& js,
                       typename std::enable_if<has_array_format<T>::value,T>::type & array,
                       JKString& s) {
  JSonArrayImpl<T> a(array); readArray(js, a, nullptr, s);
}

inline char* tocstr_(JKString& s) {   // strdup not standard
  if (s == "null" || !s.c_str()) return nullptr;
  else return (char*)::memcpy((char*)::malloc(s.size()+1), s.c_str(), s.size()+1);
}

// reads a std::string, a char*, a const char*, a bool, a char or a number.
inline void readValue(JSonSerial&, JString& var, JKString& s) {var = s;}
inline void readValue(JSonSerial&, char*& var, JKString& s) {var = tocstr_(s);}
inline void readValue(JSonSerial&, const char*& var, JKString& s) {var = tocstr_(s);}
inline void readValue(JSonSerial& js, bool& var, JKString& s) {
  if (s == "true") var = true;
  else if (s == "false") var = false;
  else js.error(JSonError::InvalidValue, s+" should be a boolean");
}
inline void readValue(JSonSerial&, char& var, JKString& s) {var = s.empty() ? 0 : s[0];}
inline void readValue(JSonSerial&, int& var, JKString& s) {var = std::stoi(s);}
inline void readValue(JSonSerial&, long& var, JKString& s) {var = std::stol(s);}
inline void readValue(JSonSerial&, long long& var, JKString& s) {var = std::stoll(s);}
inline void readValue(JSonSerial&, unsigned long& var, JKString& s) {var = std::stoul(s);}
inline void readValue(JSonSerial&, unsigned long long& var, JKString& s) {var = std::stoull(s);}
inline void readValue(JSonSerial&, float& var, JKString& s) {var = std::stof(s);}
inline void readValue(JSonSerial&, double& var, JKString& s) {var = std::stod(s);}
inline void readValue(JSonSerial&, long double& var, JKString& s) {var = std::stold(s);}

// reads a raw pointer.
template <class T>
inline void readValue(JSonSerial& js, T *& ptr, JKString& s) {
  ptr = {};
  JObjectPtr* objptr{};
  if (s != "null") readPointee<T>(js, ptr, objptr, nullptr, s);
}

// reads a value of another type.
template <class T>
inline void readValue(JSonSerial& js, T& value, JKString& s) {
  readValue2<T>(js, value, s);
}

/* reads a user object.
 * - objclass : class of the object, may be null (see below)
 * - pointerclass : class of the pointer, used as a default if no @type field
 * - obj : points to the object, if null the object is auto-created
 *   taking into account 1) @type if defined, 2) pointerclass
 * - returns a pointer to the object (whether created or not)
 */
inline void* readObject(JSonSerial& js,
                        JSonClass const* objclass, JSonClass const* pointerclass,
                        JObjectPtr*& jsp, JSonClass::Creator* cr, void* obj,
                        JKString& s) {
  if (s.empty()) js.error(JSonError::ExpectingBrace);
  else if (s[0] == '@') {  // shared object
    auto it = js.id_to_object_.find(std::strtoul(s.c_str()+1, nullptr, 0));
    if (it == js.id_to_object_.end()) js.error(JSonError::InvalidID);
    jsp = &it->second;
    return obj = it->second.raw_;
  }
  else if (s != "{") js.error(JSonError::ExpectingBrace);

  while (js.in_->good()) {
    JString name, value;
    bool found1, found2;
    js.readLine(name, value, found1, found2, true);
    if (!found1) js.error(JSonError::ExpectingPairOrBrace);
    else if (!found2 && name != "}") js.error(JSonError::ExpectingPairOrBrace);

    if (name[0]=='@' && name != "@class" && name != "@id")
      js.error(JSonError::WrongKeyword, value);

    if (!objclass) {  // search class
      if (name != "@class") objclass = pointerclass;
      else { // polymorphism
        objclass = js.classes_->getClass(value);
        if (!objclass) js.error(JSonError::UnknownClass, value);
      }
      if (!obj) { // create object if it does not exist
        if (cr) obj = cr->create();
        else obj = objclass->create();
      }
      if (!obj) js.error(JSonError::AbstractClass, objclass->className());
      if (name == "@class") continue;
    }

    if (name == "}") {objclass->doPostRead(obj); return obj;}  // end of object
    else if (name == "@id") {  // id of object
      jsp = &js.id_to_object_[std::stoul(value)];
      jsp->raw_ = obj;
      continue;
    }
    else try {
      if (!objclass->readMember(js, obj, name, value))
        js.error(JSonError::UnknownMember,
                 "'" +name + "' in class '" + objclass->className()+"'");
    }
    catch (std::invalid_argument) {
      js.error(JSonError::InvalidValue, value+" for member '"+name+"'");
    }
  }
  js.error(JSonError::PrematureEOF);
  return nullptr;
}

// reads a C++ container or a C-array.
inline void readArray(JSonSerial& js, JSonArray& a, JSonClass::Creator* cr, JKString& s) {
  if (s != "[") js.error(JSonError::ExpectingBracket);
  while (js.in_->good()) {
    JString tok, dump;
    bool found1, found2;
    js.readLine(tok, dump, found1, found2, false);
    if (!found1) js.error(JSonError::ExpectingValueOrBracket);
    else if (tok == "]") {a.end(js); return;} // end of array
    //else if (tok == "null");  // null element ignored
    else a.add(js, cr, tok);
  }
}

// reads a smart pointer in an array/container.
template <class T>
inline void readArrayValue2(JSonSerial& js,
                            typename std::enable_if<is_smart_ptr<T>::value,T>::type & e,
                            JObjectPtr*& objptr, JSonClass::Creator* cr, JKString& s) {
  e.reset();
  if (s != "null") readPointee<T>(js, e, objptr, cr, s);
}

// reads anything else in an array/container.
template <class T>
inline void readArrayValue2(JSonSerial& js,
                            typename std::enable_if<!is_smart_ptr<T>::value,T>::type & e,
                            JObjectPtr*&, JSonClass::Creator*, JKString& s) {
  readValue(js, e, s);
}

// reads a char* in an array/container.
inline void readArrayValue(JSonSerial& js, char* & e,
                           JObjectPtr*&, JSonClass::Creator*, JKString& s) {
  e = nullptr;
  readValue(js, e, s);
}

// reads a const char* in an array/container.
inline void readArrayValue(JSonSerial& js, const char* & e,
                           JObjectPtr*&, JSonClass::Creator*, JKString& s) {
  e = nullptr;
  readValue(js, e, s);
}

// reads a raw pointer in an array/container.
template <class T>
inline void readArrayValue(JSonSerial& js, T *& e, JObjectPtr*& objptr,
                           JSonClass::Creator* cr, JKString& s) {
  e = nullptr;
  if (s != "null") readPointee<T>(js, e, objptr, cr, s);
}

// reads anything in an array/container except a char* or a raw pointer.
template <class T>
inline void readArrayValue(JSonSerial& js, T & e, JObjectPtr*& objptr,
                           JSonClass::Creator* cr, JKString& s) {
  readArrayValue2<T>(js, e, objptr, cr, s);
}


template <typename C, typename R>
struct ObjectCreatorImpl : public JSonClass::Creator {
  ObjectCreatorImpl(C& obj, std::function<R(C&)> creator)
  : obj_(obj), creator_(creator) {}
  C& obj_;
  std::function<R(C&)> creator_;
  void* create() override {return (creator_)(obj_);}
};

template <typename T, typename Var>
struct StaticMember : public JSonUserClass<T>::Member {
  StaticMember(JKString& name, Var& var) : JSonUserClass<T>::Member(name), variable_(var) {}
  void read(JSonSerial& js, T&, JKString& val) override {readValue(js, variable_, val);}
  void write(JSonSerial& js, const T&) override {js.writeValue(variable_);}
protected:
  Var& variable_;
};

template <typename T, typename Var>
struct InstanceMember : public JSonUserClass<T>::Member {
  InstanceMember(JKString& name, Var T::* var) : JSonUserClass<T>::Member(name), variable_(var) {}
  void read(JSonSerial& js, T& obj, JKString& val) override {readValue(js, obj.*variable_, val);}
  void write(JSonSerial& js, const T& obj) override {js.writeValue(obj.*variable_);}
protected:
  Var T::* variable_;
};

template <typename T, typename Var>
struct InstanceMemberWithCond : public JSonUserClass<T>::Member {
  InstanceMemberWithCond(JKString& name, Var T::* var, std::function<bool(const T&)> write_if)
  : JSonUserClass<T>::Member(name), variable_(var), write_if_(write_if) {}
  void read(JSonSerial& js, T& obj, JKString& val) override {readValue(js, obj.*variable_, val);}
  void write(JSonSerial& js, const T& obj) override {if ((write_if_)(obj)) js.writeValue(obj.*variable_);}
protected:
  Var T::* variable_;
  std::function<bool(const T&)> write_if_;
};

template <typename T, typename Var, typename R>
struct InstanceMemberWithCreator : public JSonUserClass<T>::Member {
  InstanceMemberWithCreator(JKString& name, Var T::* var, std::function<R(T&)> creator)
  : JSonUserClass<T>::Member(name), variable_(var), creator_(creator) {}
  void read(JSonSerial& js, T& obj, JKString& s) override {
    ObjectCreatorImpl<T,R> c(obj, creator_);
    obj.*variable_ = nullptr;
    JObjectPtr* jsp{nullptr};
    using TObj = typename std::remove_pointer<Var>::type;
    if (s != "null") readPointee<TObj>(js, (obj.*variable_), jsp, &c, s);
  }
  void write(JSonSerial& js, const T& obj) override {js.writeValue(obj.*variable_);}
protected:
  Var T::* variable_;
  std::function<R(T&)> creator_;
};

template <typename T, typename Var, typename R>
struct ArrayMemberWithCreator : public JSonUserClass<T>::Member {
  ArrayMemberWithCreator(JKString& name, Var T::* var, std::function<R(T&)> creator)
  : JSonUserClass<T>::Member(name), variable_(var), creator_(creator) {}
  void read(JSonSerial& js, T& obj, JKString& s) override {
    ObjectCreatorImpl<T,R> c(obj, creator_);
    JSonArrayImpl<Var> a(obj.*variable_);
    readArray(js, a, &c, s);
  }
  void write(JSonSerial& js, const T& obj) override {js.writeValue(obj.*variable_);}
protected:
  Var T::* variable_;
  std::function<R(T&)> creator_;
};

template <typename T, typename SetVal, typename GetVal>
struct InstanceMemberWithAccessor : public JSonUserClass<T>::Member  {
  InstanceMemberWithAccessor(JKString& name, void(T::*setter)(SetVal), GetVal(T::*getter)()const)
  : JSonUserClass<T>::Member(name), setter_(setter), getter_(getter) {}
  void read(JSonSerial& js, T& obj, JKString& val) override {
    typename std::remove_const<typename std::remove_reference<SetVal>::type>::type var;
    readValue(js, var, val);
    (obj.*setter_)(std::move(var)); // allow move when possible
  }
  void write(JSonSerial& js, const T& obj) override {js.writeValue((obj.*getter_)());}
protected:
  void (T::*setter_)(SetVal);
  GetVal (T::*getter_)() const;
};

template <typename T>
struct InstanceCustomMember : public JSonUserClass<T>::Member {
  InstanceCustomMember(JKString& name,
                       std::function<void(T&, JSonSerial&, JKString&)> readfun,
                       std::function<void(const T&, JSonSerial&)> writefun)
  : JSonUserClass<T>::Member(name), readfun_(readfun), writefun_(writefun) {}
  bool isCustom() const override {return true;}
  void read(JSonSerial& js, T& obj, JKString& val) override {(readfun_)(obj,js,val);}
  void write(JSonSerial& js, const T& obj) override {(writefun_)(obj,js);}
protected:
  std::function<void(T&, JSonSerial&, JKString&)> readfun_;
  std::function<void(const T&, JSonSerial&)> writefun_;
};

template <class T>
template <typename Var>
JSonUserClass<T>& JSonUserClass<T>::addMember(JKString& name, Var& var) {
  addMember(name, new StaticMember<T,Var>(name, var));
  return *this;
}

template <class T>
template <typename Var, typename C>
JSonUserClass<T>& JSonUserClass<T>::addMember(JKString& name, Var C::* var) {
  addMember(name, new InstanceMember<T,Var>(name, var));
  return *this;
}

template <class T>
template <typename SetVal, typename GetVal>
JSonUserClass<T>& JSonUserClass<T>::addMember(JKString& name,
                                              void (T::*setter)(SetVal), GetVal (T::*getter)() const) {
  addMember(name, new InstanceMemberWithAccessor<T,SetVal,GetVal>(name, setter, getter));
  return *this;
}

template <class T>
template <typename Var>
JSonUserClass<T>& JSonUserClass<T>::addMember(JKString& name, Var T::* var,
                                              std::function<typename makeptr<Var>::type(T&)> cr) {
  addMember(name, new InstanceMemberWithCreator<T,Var, typename makeptr<Var>::type>(name, var, cr));
  return *this;
}

template <class T>
template <typename Var>
JSonUserClass<T>& JSonUserClass<T>::addMember(JKString& name, Var T::* var,
                                              std::function<typename makearrayptr<Var>::type(T&)> cr) {
  addMember(name, new ArrayMemberWithCreator<T,Var, typename makearrayptr<Var>::type>(name, var, cr));
  return *this;
}

template <class T>
JSonUserClass<T>& JSonUserClass<T>::addMember(JKString& name,
                                              std::function<void(T&, JSonSerial&, JKString&)> read,
                                              std::function<void(const T&, JSonSerial&)> write) {
  addMember(name, new InstanceCustomMember<T>(name, read, write));
  return *this;
}

template <class T>
template <typename Super>
JSonUserClass<T>& JSonUserClass<T>::extends() {
  static_assert(std::is_base_of<Super, T>::value, "extends(): Not a superclass");
  const JSonClass* c = classes_.getClass(typeid(Super));
  if (!c) classes_.error(JSonError::UnknownSuperclass,
                         JString(": superclass ")+typeid(Super).name()+" of class "+classname_, "extends()");
  else {
    bool added{false};
    for (auto& it : superclasses_) {if (it.super_ == c) added = true;}
    if (!added) superclasses_.template add<Super>(c);
    else classes_.error(JSonError::RedefinedSuperclass,
                        ": superclass "+c->className()+" of class "+classname_, "extends()");
  }
  return *this;
}

template <class T>
void JSonUserClass<T>::addMember(JKString& name, Member* m) {
  if (getMember(name))
    classes_.error(JSonError::RedefinedMember,": member "+name+" of class "+classname_, "member()");
  else
    members_.push_back(m); membermap_[name] = m;
}

template <class T>
typename JSonUserClass<T>::Member* JSonUserClass<T>::getMember(JKString& name) const {
  auto it = membermap_.find(name);
  return (it == membermap_.end()) ? nullptr : it->second;
}

template <class T>
bool JSonUserClass<T>::readMember(JSonSerial& js, void* obj, JKString& name, JKString& val) const {
  if (!obj) js.error(JSonError::UnexpectedNull);
  if (auto mb = getMember(name)) {    // search in subclass first
    mb->read(js, *static_cast<T*>(obj), val);
    return true;
  }
  for (auto& it : superclasses_) {    // if not found, search in superclasses
    if (it.super_->readMember(js, (it.upcast_)(obj), name, val)) return true;
  }
  return false;
}

template <class T>
void JSonUserClass<T>::writeMembers(JSonSerial& js, const void* obj) const {
  if (!obj) js.error(JSonError::UnexpectedNull);
  for (auto& it : superclasses_) {    // print members in superclasses first
    it.super_->writeMembers(js, (it.upcast_)((void*)obj));
  }
  for (auto& it : members_) {  // then print members (can't be shadowed!)
    if (js.needcomma_) *(js.out_) << ",\n"; js.needcomma_ = false;
    if (it->isCustom()) js.token1_ = it->name();
    else {js.writeTabs(); *(js.out_) << '"' << it->name() << "\": ";}
    it->write(js, *static_cast<const T*>(obj));
  }
}

template <class T>
void JSonUserClass<T>::doPostRead(void* obj) const {
  if (obj && postread_) postread_(*static_cast<T*>(obj));
}

template <class T>
void JSonUserClass<T>::doPostWrite(const void* obj) const {
  if (obj && postwrite_) postwrite_(*static_cast<const T*>(obj));
}

template <class T>
bool JMapClass<T>::readMember(JSonSerial& js, void* map, JKString& key, JKString& val) const {
  using E = typename T::mapped_type;
  readValue(js, (*static_cast<T*>(map))[key] = E{}, val);
  return true;
}

template <class T>
void JMapClass<T>::writeMembers(JSonSerial& js, const void* map) const {
  for (auto& it : *static_cast<const T*>(map)) {
    if (js.needcomma_) *(js.out_) << ",\n";
    js.needcomma_ = false;
    js.writeTabs(); *(js.out_) << '"' << it.first << "\": ";
    js.writeValue(it.second);
  }
}

template <class T>
JSonUserClass<T> & JSonClasses::addClass(JKString& classname, std::function<T*()> creator) {
  if (getClass(classname)) error(JSonError::RedefinedClass, classname, "add()");
  JSonUserClass<T>* cl = new JSonUserClass<T>(*this, classname, creator);
  classindexes_[std::type_index(typeid(T))] = classnames_[classname] = cl;
  return *cl;
}

// add element to a C-array with brackets.
template<class T>
struct JSonArrayImpl<T, typename std::enable_if<std::is_array<T>::value>::type> : public JSonArray {
  JSonArrayImpl(T& array) : array_(array), index_(0) {}
  void add(JSonSerial& js, JSonClass::Creator* cr, JKString& s) override {
    JObjectPtr* jsp{};
    if (index_ >= std::extent<T>::value) js.error(JSonError::CantAddToArray);
    else readArrayValue(js, array_[index_++], jsp, cr, s);
  }
  T& array_;
  size_t index_;
};

}
#endif