fix cpp lint in json11 (#2975)

* indent and constructor

* fix more

* fix long
Co-authored-by: StrikerRUS <nekit94-12@hotmail.com>

include/LightGBM/utils/json11.h

@@ -21,55 +21,55 @@
 
 /* json11
  *
- * json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
+ * json11 is a tiny JSON library for C++11, providing JSON parsing and
+ * serialization.
  *
- * The core object provided by the library is json11::Json. A Json object represents any JSON
- * value: null, bool, number (int or double), string (std::string), array (std::vector), or
- * object (std::map).
+ * The core object provided by the library is json11::Json. A Json object
+ * represents any JSON value: null, bool, number (int or double), string
+ * (std::string), array (std::vector), or object (std::map).
  *
- * Json objects act like values: they can be assigned, copied, moved, compared for equality or
- * order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and
- * Json::parse (static) to parse a std::string as a Json object.
+ * Json objects act like values: they can be assigned, copied, moved, compared
+ * for equality or order, etc. There are also helper methods Json::dump, to
+ * serialize a Json to a string, and Json::parse (static) to parse a std::string
+ * as a Json object.
  *
- * Internally, the various types of Json object are represented by the JsonValue class
- * hierarchy.
+ * Internally, the various types of Json object are represented by the JsonValue
+ * class hierarchy.
  *
- * A note on numbers - JSON specifies the syntax of number formatting but not its semantics,
- * so some JSON implementations distinguish between integers and floating-point numbers, while
- * some don't. In json11, we choose the latter. Because some JSON implementations (namely
- * Javascript itself) treat all numbers as the same type, distinguishing the two leads
- * to JSON that will be *silently* changed by a round-trip through those implementations.
- * Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also
+ * A note on numbers - JSON specifies the syntax of number formatting but not
+ * its semantics, so some JSON implementations distinguish between integers and
+ * floating-point numbers, while some don't. In json11, we choose the latter.
+ * Because some JSON implementations (namely Javascript itself) treat all
+ * numbers as the same type, distinguishing the two leads to JSON that will be
+ * *silently* changed by a round-trip through those implementations. Dangerous!
+ * To avoid that risk, json11 stores all numbers as double internally, but also
  * provides integer helpers.
  *
- * Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the
- * range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64
- * or long long to avoid the Y2038K problem; a double storing microseconds since some epoch
- * will be exact for +/- 275 years.)
+ * Fortunately, double-precision IEEE754 ('double') can precisely store any
+ * integer in the range +/-2^53, which includes every 'int' on most systems.
+ * (Timestamps often use int64 or long long to avoid the Y2038K problem; a
+ * double storing microseconds since some epoch will be exact for +/- 275
+ * years.)
  */
 #pragma once
 
-#include <string>
 #include <initializer_list>
 #include <map>
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
 namespace json11 {
 
-enum JsonParse {
-    STANDARD, COMMENTS
-};
+enum JsonParse { STANDARD, COMMENTS };
 
 class JsonValue;
 
 class Json final {
  public:
   // Types
-    enum Type {
-        NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
-    };
+  enum Type { NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT };
 
   // Array and object typedefs
   typedef std::vector<Json> array;
@@ -77,38 +77,44 @@ class Json final {
 
   // Constructors for the various types of JSON value.
   Json() noexcept;                          // NUL
-    Json(std::nullptr_t) noexcept;   // NUL
-    Json(double value);              // NUMBER
-    Json(int value);                 // NUMBER
-    Json(bool value);                // BOOL
-    Json(const std::string &value);  // STRING
-    Json(std::string &&value);       // STRING
-    Json(const char * value);        // STRING
-    Json(const array &values);       // ARRAY
-    Json(array &&values);            // ARRAY
-    Json(const object &values);      // OBJECT
-    Json(object &&values);           // OBJECT
+  explicit Json(std::nullptr_t) noexcept;   // NUL
+  explicit Json(double value);              // NUMBER
+  explicit Json(int value);                 // NUMBER
+  explicit Json(bool value);                // BOOL
+  explicit Json(const std::string &value);  // STRING
+  explicit Json(std::string &&value);       // STRING
+  explicit Json(const char *value);         // STRING
+  explicit Json(const array &values);       // ARRAY
+  explicit Json(array &&values);            // ARRAY
+  explicit Json(const object &values);      // OBJECT
+  explicit Json(object &&values);           // OBJECT
 
   // Implicit constructor: anything with a to_json() function.
   template <class T, class = decltype(&T::to_json)>
-    Json(const T & t) : Json(t.to_json()) {}
+  explicit Json(const T &t) : Json(t.to_json()) {}
 
   // Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
-    template <class M, typename std::enable_if<
-        std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value
-        && std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value,
+  template <
+      class M,
+      typename std::enable_if<
+          std::is_constructible<
+              std::string, decltype(std::declval<M>().begin()->first)>::value &&
+              std::is_constructible<
+                  Json, decltype(std::declval<M>().begin()->second)>::value,
           int>::type = 0>
-    Json(const M & m) : Json(object(m.begin(), m.end())) {}
+  explicit Json(const M &m) : Json(object(m.begin(), m.end())) {}
 
-    // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
+  // Implicit constructor: vector-like objects (std::list, std::vector,
+  // std::set, etc)
   template <class V, typename std::enable_if<
-        std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value,
+                         std::is_constructible<
+                             Json, decltype(*std::declval<V>().begin())>::value,
                          int>::type = 0>
-    Json(const V & v) : Json(array(v.begin(), v.end())) {}
+  explicit Json(const V &v) : Json(array(v.begin(), v.end())) {}
 
   // This prevents Json(some_pointer) from accidentally producing a bool. Use
   // Json(bool(some_pointer)) if that behavior is desired.
-    Json(void *) = delete;
+  explicit Json(void *) = delete;
 
   // Accessors
   Type type() const;
@@ -120,9 +126,10 @@ class Json final {
   bool is_array() const { return type() == ARRAY; }
   bool is_object() const { return type() == OBJECT; }
 
-    // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not
-    // distinguish between integer and non-integer numbers - number_value() and int_value()
-    // can both be applied to a NUMBER-typed object.
+  // Return the enclosed value if this is a number, 0 otherwise. Note that
+  // json11 does not distinguish between integer and non-integer numbers -
+  // number_value() and int_value() can both be applied to a NUMBER-typed
+  // object.
   double number_value() const;
   int int_value() const;
 
@@ -130,82 +137,81 @@ class Json final {
   bool bool_value() const;
   // Return the enclosed string if this is a string, "" otherwise.
   const std::string &string_value() const;
-    // Return the enclosed std::vector if this is an array, or an empty vector otherwise.
+  // Return the enclosed std::vector if this is an array, or an empty vector
+  // otherwise.
   const array &array_items() const;
-    // Return the enclosed std::map if this is an object, or an empty map otherwise.
+  // Return the enclosed std::map if this is an object, or an empty map
+  // otherwise.
   const object &object_items() const;
 
   // Return a reference to arr[i] if this is an array, Json() otherwise.
-    const Json & operator[](size_t i) const;
+  const Json &operator[](size_t i) const;
   // Return a reference to obj[key] if this is an object, Json() otherwise.
-    const Json & operator[](const std::string &key) const;
+  const Json &operator[](const std::string &key) const;
 
   // Serialize.
-    void dump(std::string &out) const;
+  void dump(std::string *out) const;
   std::string dump() const {
     std::string out;
-        dump(out);
+    dump(&out);
     return out;
   }
 
   // Parse. If parse fails, return Json() and assign an error message to err.
-    static Json parse(const std::string & in,
-                      std::string & err,
+  static Json parse(const std::string &in, std::string *err,
                     JsonParse strategy = JsonParse::STANDARD);
-    static Json parse(const char * in,
-                      std::string & err,
+  static Json parse(const char *in, std::string *err,
                     JsonParse strategy = JsonParse::STANDARD) {
     if (in) {
       return parse(std::string(in), err, strategy);
     } else {
-            err = "null input";
-            return nullptr;
+      *err = "null input";
+      return Json(nullptr);
     }
   }
   // Parse multiple objects, concatenated or separated by whitespace
   static std::vector<Json> parse_multi(
-        const std::string & in,
-        std::string::size_type & parser_stop_pos,
-        std::string & err,
-        JsonParse strategy = JsonParse::STANDARD);
+      const std::string &in, std::string::size_type *parser_stop_pos,
+      std::string *err, JsonParse strategy = JsonParse::STANDARD);
 
   static inline std::vector<Json> parse_multi(
-        const std::string & in,
-        std::string & err,
+      const std::string &in, std::string *err,
       JsonParse strategy = JsonParse::STANDARD) {
     std::string::size_type parser_stop_pos;
-        return parse_multi(in, parser_stop_pos, err, strategy);
+    return parse_multi(in, &parser_stop_pos, err, strategy);
   }
 
-    bool operator== (const Json &rhs) const;
-    bool operator<  (const Json &rhs) const;
-    bool operator!= (const Json &rhs) const { return !(*this == rhs); }
-    bool operator<= (const Json &rhs) const { return !(rhs < *this); }
-    bool operator>  (const Json &rhs) const { return  (rhs < *this); }
-    bool operator>= (const Json &rhs) const { return !(*this < rhs); }
+  bool operator==(const Json &rhs) const;
+  bool operator<(const Json &rhs) const;
+  bool operator!=(const Json &rhs) const { return !(*this == rhs); }
+  bool operator<=(const Json &rhs) const { return !(rhs < *this); }
+  bool operator>(const Json &rhs) const { return (rhs < *this); }
+  bool operator>=(const Json &rhs) const { return !(*this < rhs); }
 
   /* has_shape(types, err)
    *
-     * Return true if this is a JSON object and, for each item in types, has a field of
-     * the given type. If not, return false and set err to a descriptive message.
+   * Return true if this is a JSON object and, for each item in types, has a
+   * field of the given type. If not, return false and set err to a descriptive
+   * message.
    */
   typedef std::initializer_list<std::pair<std::string, Type>> shape;
-    bool has_shape(const shape & types, std::string & err) const;
+  bool has_shape(const shape &types, std::string *err) const;
 
  private:
   std::shared_ptr<JsonValue> m_ptr;
 };
 
-// Internal class hierarchy - JsonValue objects are not exposed to users of this API.
+// Internal class hierarchy - JsonValue objects are not exposed to users of this
+// API.
 class JsonValue {
  protected:
   friend class Json;
   friend class JsonInt;
   friend class JsonDouble;
   virtual Json::Type type() const = 0;
-    virtual bool equals(const JsonValue * other) const = 0;
-    virtual bool less(const JsonValue * other) const = 0;
-    virtual void dump(std::string &out) const = 0;
+  virtual bool equals(const JsonValue *other) const = 0;
+  virtual bool less(const JsonValue *other) const = 0;
+  virtual void dump(std::string *out) const = 0;
   virtual double number_value() const;
   virtual int int_value() const;
   virtual bool bool_value() const;

src/boosting/gbdt.cpp

@@ -64,7 +64,7 @@ void GBDT::Init(const Config* config, const Dataset* train_data, const Objective
     std::stringstream buffer;
     buffer << forced_splits_file.rdbuf();
     std::string err;
-    forced_splits_json_ = Json::parse(buffer.str(), err);
+    forced_splits_json_ = Json::parse(buffer.str(), &err);
   }
 
   objective_function_ = objective_function;
@@ -725,7 +725,7 @@ void GBDT::ResetConfig(const Config* config) {
       std::stringstream buffer;
       buffer << forced_splits_file.rdbuf();
       std::string err;
-      forced_splits_json_ = Json::parse(buffer.str(), err);
+      forced_splits_json_ = Json::parse(buffer.str(), &err);
       tree_learner_->SetForcedSplit(&forced_splits_json_);
     } else {
       forced_splits_json_ = Json();

src/io/dataset_loader.cpp

@@ -1208,7 +1208,7 @@ std::vector<std::vector<double>> DatasetLoader::GetForcedBins(std::string forced
       std::stringstream buffer;
       buffer << forced_bins_stream.rdbuf();
       std::string err;
-      Json forced_bins_json = Json::parse(buffer.str(), err);
+      Json forced_bins_json = Json::parse(buffer.str(), &err);
       CHECK(forced_bins_json.is_array());
       std::vector<Json> forced_bins_arr = forced_bins_json.array_items();
       for (size_t i = 0; i < forced_bins_arr.size(); ++i) {

src/io/json11.cpp

@@ -31,12 +31,12 @@ namespace json11 {
 
 static const int max_depth = 200;
 
-using std::string;
-using std::vector;
-using std::map;
-using std::make_shared;
 using std::initializer_list;
+using std::make_shared;
+using std::map;
 using std::move;
+using std::string;
+using std::vector;
 
 using LightGBM::Log;
 
@@ -53,96 +53,90 @@ struct NullStruct {
  * Serialization
  */
 
-static void dump(NullStruct, string &out) {
-    out += "null";
-}
+static void dump(NullStruct, string *out) { *out += "null"; }
 
-static void dump(double value, string &out) {
+static void dump(double value, string *out) {
   if (std::isfinite(value)) {
     char buf[32];
     snprintf(buf, sizeof buf, "%.17g", value);
-        out += buf;
+    *out += buf;
   } else {
-        out += "null";
+    *out += "null";
   }
 }
 
-static void dump(int value, string &out) {
+static void dump(int value, string *out) {
   char buf[32];
   snprintf(buf, sizeof buf, "%d", value);
-    out += buf;
+  *out += buf;
 }
 
-static void dump(bool value, string &out) {
-    out += value ? "true" : "false";
-}
+static void dump(bool value, string *out) { *out += value ? "true" : "false"; }
 
-static void dump(const string &value, string &out) {
-    out += '"';
+static void dump(const string &value, string *out) {
+  *out += '"';
   for (size_t i = 0; i < value.length(); i++) {
     const char ch = value[i];
     if (ch == '\\') {
-            out += "\\\\";
+      *out += "\\\\";
     } else if (ch == '"') {
-            out += "\\\"";
+      *out += "\\\"";
     } else if (ch == '\b') {
-            out += "\\b";
+      *out += "\\b";
     } else if (ch == '\f') {
-            out += "\\f";
+      *out += "\\f";
     } else if (ch == '\n') {
-            out += "\\n";
+      *out += "\\n";
     } else if (ch == '\r') {
-            out += "\\r";
+      *out += "\\r";
     } else if (ch == '\t') {
-            out += "\\t";
+      *out += "\\t";
     } else if (static_cast<uint8_t>(ch) <= 0x1f) {
       char buf[8];
       snprintf(buf, sizeof buf, "\\u%04x", ch);
-            out += buf;
-        } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
-                   && static_cast<uint8_t>(value[i+2]) == 0xa8) {
-            out += "\\u2028";
+      *out += buf;
+    } else if (static_cast<uint8_t>(ch) == 0xe2 &&
+               static_cast<uint8_t>(value[i + 1]) == 0x80 &&
+               static_cast<uint8_t>(value[i + 2]) == 0xa8) {
+      *out += "\\u2028";
       i += 2;
-        } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
-                   && static_cast<uint8_t>(value[i+2]) == 0xa9) {
-            out += "\\u2029";
+    } else if (static_cast<uint8_t>(ch) == 0xe2 &&
+               static_cast<uint8_t>(value[i + 1]) == 0x80 &&
+               static_cast<uint8_t>(value[i + 2]) == 0xa9) {
+      *out += "\\u2029";
       i += 2;
     } else {
-            out += ch;
+      *out += ch;
     }
   }
-    out += '"';
+  *out += '"';
 }
 
-static void dump(const Json::array &values, string &out) {
+static void dump(const Json::array &values, string *out) {
   bool first = true;
-    out += "[";
+  *out += "[";
   for (const auto &value : values) {
-        if (!first)
-            out += ", ";
+    if (!first) *out += ", ";
     value.dump(out);
     first = false;
   }
-    out += "]";
+  *out += "]";
 }
 
-static void dump(const Json::object &values, string &out) {
+static void dump(const Json::object &values, string *out) {
   bool first = true;
-    out += "{";
+  *out += "{";
   for (const auto &kv : values) {
-        if (!first)
-            out += ", ";
+    if (!first) *out += ", ";
     dump(kv.first, out);
-        out += ": ";
+    *out += ": ";
     kv.second.dump(out);
     first = false;
   }
-    out += "}";
+  *out += "}";
 }
 
-void Json::dump(string &out) const {
-    m_ptr->dump(out);
-}
+void Json::dump(string *out) const { m_ptr->dump(out); }
 
 /* * * * * * * * * * * * * * * * * * * *
  * Value wrappers
@@ -156,27 +150,30 @@ class Value : public JsonValue {
   explicit Value(T &&value) : m_value(move(value)) {}
 
   // Get type tag
-    Json::Type type() const override {
-        return tag;
-    }
+  Json::Type type() const override { return tag; }
 
   // Comparisons
-    bool equals(const JsonValue * other) const override {
+  bool equals(const JsonValue *other) const override {
     return m_value == static_cast<const Value<tag, T> *>(other)->m_value;
   }
-    bool less(const JsonValue * other) const override {
+  bool less(const JsonValue *other) const override {
     return m_value < (static_cast<const Value<tag, T> *>(other)->m_value);
   }
 
   const T m_value;
-    void dump(string &out) const override { json11::dump(m_value, out); }
+  void dump(string *out) const override { json11::dump(m_value, out); }
 };
 
 class JsonDouble final : public Value<Json::NUMBER, double> {
   double number_value() const override { return m_value; }
   int int_value() const override { return static_cast<int>(m_value); }
-    bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
-    bool less(const JsonValue * other)   const override { return m_value <  other->number_value(); }
+  bool equals(const JsonValue *other) const override {
+    return m_value == other->number_value();
+  }
+  bool less(const JsonValue *other) const override {
+    return m_value < other->number_value();
+  }
+
  public:
   explicit JsonDouble(double value) : Value(value) {}
 };
@@ -184,20 +181,27 @@ class JsonDouble final : public Value<Json::NUMBER, double> {
 class JsonInt final : public Value<Json::NUMBER, int> {
   double number_value() const override { return m_value; }
   int int_value() const override { return m_value; }
-    bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
-    bool less(const JsonValue * other)   const override { return m_value <  other->number_value(); }
+  bool equals(const JsonValue *other) const override {
+    return m_value == other->number_value();
+  }
+  bool less(const JsonValue *other) const override {
+    return m_value < other->number_value();
+  }
+
  public:
   explicit JsonInt(int value) : Value(value) {}
 };
 
 class JsonBoolean final : public Value<Json::BOOL, bool> {
   bool bool_value() const override { return m_value; }
+
  public:
   explicit JsonBoolean(bool value) : Value(value) {}
 };
 
 class JsonString final : public Value<Json::STRING, string> {
   const string &string_value() const override { return m_value; }
+
  public:
   explicit JsonString(const string &value) : Value(value) {}
   explicit JsonString(string &&value) : Value(move(value)) {}
@@ -205,7 +209,8 @@ class JsonString final : public Value<Json::STRING, string> {
 
 class JsonArray final : public Value<Json::ARRAY, Json::array> {
   const Json::array &array_items() const override { return m_value; }
-    const Json & operator[](size_t i) const override;
+  const Json &operator[](size_t i) const override;
+
  public:
   explicit JsonArray(const Json::array &value) : Value(value) {}
   explicit JsonArray(Json::array &&value) : Value(move(value)) {}
@@ -213,7 +218,8 @@ class JsonArray final : public Value<Json::ARRAY, Json::array> {
 
 class JsonObject final : public Value<Json::OBJECT, Json::object> {
   const Json::object &object_items() const override { return m_value; }
-    const Json & operator[](const string &key) const override;
+  const Json &operator[](const string &key) const override;
+
  public:
   explicit JsonObject(const Json::object &value) : Value(value) {}
   explicit JsonObject(Json::object &&value) : Value(move(value)) {}
@@ -237,13 +243,14 @@ struct Statics {
   Statics() {}
 };
 
-static const Statics & statics() {
-    static const Statics s {};
+static const Statics &statics() {
+  static const Statics s{};
   return s;
 }
 
-static const Json & static_null() {
-    // This has to be separate, not in Statics, because Json() accesses statics().null.
+static const Json &static_null() {
+  // This has to be separate, not in Statics, because Json() accesses
+  // statics().null.
   static const Json json_null;
   return json_null;
 }
@@ -259,11 +266,14 @@ Json::Json(int value)                  : m_ptr(make_shared<JsonInt>(value)) {}
 Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {}
 Json::Json(const string &value) : m_ptr(make_shared<JsonString>(value)) {}
 Json::Json(string &&value) : m_ptr(make_shared<JsonString>(move(value))) {}
-Json::Json(const char * value)         : m_ptr(make_shared<JsonString>(value)) {}
+Json::Json(const char *value) : m_ptr(make_shared<JsonString>(value)) {}
 Json::Json(const Json::array &values) : m_ptr(make_shared<JsonArray>(values)) {}
-Json::Json(Json::array &&values)       : m_ptr(make_shared<JsonArray>(move(values))) {}
-Json::Json(const Json::object &values) : m_ptr(make_shared<JsonObject>(values)) {}
-Json::Json(Json::object &&values)      : m_ptr(make_shared<JsonObject>(move(values))) {}
+Json::Json(Json::array &&values)
+    : m_ptr(make_shared<JsonArray>(move(values))) {}
+Json::Json(const Json::object &values)
+    : m_ptr(make_shared<JsonObject>(values)) {}
+Json::Json(Json::object &&values)
+    : m_ptr(make_shared<JsonObject>(move(values))) {}
 
 /* * * * * * * * * * * * * * * * * * * *
  * Accessors
@@ -273,26 +283,34 @@ Json::Type Json::type()                           const { return m_ptr->type();
 double Json::number_value() const { return m_ptr->number_value(); }
 int Json::int_value() const { return m_ptr->int_value(); }
 bool Json::bool_value() const { return m_ptr->bool_value(); }
-const string & Json::string_value()               const { return m_ptr->string_value(); }
-const vector<Json> & Json::array_items()          const { return m_ptr->array_items();  }
-const map<string, Json> & Json::object_items()    const { return m_ptr->object_items(); }
-const Json & Json::operator[] (size_t i)          const { return (*m_ptr)[i];           }
-const Json & Json::operator[] (const string &key) const { return (*m_ptr)[key];         }
+const string &Json::string_value() const { return m_ptr->string_value(); }
+const vector<Json> &Json::array_items() const { return m_ptr->array_items(); }
+const map<string, Json> &Json::object_items() const {
+  return m_ptr->object_items();
+}
+const Json &Json::operator[](size_t i) const { return (*m_ptr)[i]; }
+const Json &Json::operator[](const string &key) const { return (*m_ptr)[key]; }
 
 double JsonValue::number_value() const { return 0; }
 int JsonValue::int_value() const { return 0; }
 bool JsonValue::bool_value() const { return false; }
-const string &            JsonValue::string_value()              const { return statics().empty_string; }
-const vector<Json> &      JsonValue::array_items()               const { return statics().empty_vector; }
-const map<string, Json> & JsonValue::object_items()              const { return statics().empty_map; }
-const Json &              JsonValue::operator[] (size_t)         const { return static_null(); }
-const Json &              JsonValue::operator[] (const string &) const { return static_null(); }
+const string &JsonValue::string_value() const { return statics().empty_string; }
+const vector<Json> &JsonValue::array_items() const {
+  return statics().empty_vector;
+}
+const map<string, Json> &JsonValue::object_items() const {
+  return statics().empty_map;
+}
+const Json &JsonValue::operator[](size_t) const { return static_null(); }
+const Json &JsonValue::operator[](const string &) const {
+  return static_null();
+}
 
-const Json & JsonObject::operator[] (const string &key) const {
+const Json &JsonObject::operator[](const string &key) const {
   auto iter = m_value.find(key);
   return (iter == m_value.end()) ? static_null() : iter->second;
 }
-const Json & JsonArray::operator[] (size_t i) const {
+const Json &JsonArray::operator[](size_t i) const {
   if (i >= m_value.size())
     return static_null();
   else
@@ -303,18 +321,15 @@ const Json & JsonArray::operator[] (size_t i) const {
  * Comparison
  */
 
-bool Json::operator== (const Json &other) const {
-    if (m_ptr == other.m_ptr)
-        return true;
-    if (m_ptr->type() != other.m_ptr->type())
-        return false;
+bool Json::operator==(const Json &other) const {
+  if (m_ptr == other.m_ptr) return true;
+  if (m_ptr->type() != other.m_ptr->type()) return false;
 
   return m_ptr->equals(other.m_ptr.get());
 }
 
-bool Json::operator< (const Json &other) const {
-    if (m_ptr == other.m_ptr)
-        return false;
+bool Json::operator<(const Json &other) const {
+  if (m_ptr == other.m_ptr) return false;
   if (m_ptr->type() != other.m_ptr->type())
     return m_ptr->type() < other.m_ptr->type();
 
@@ -339,7 +354,8 @@ static inline string esc(char c) {
   return string(buf);
 }
 
-static inline bool in_range(long x, long lower, long upper) {
+template <typename T>
+static inline bool in_range(T x, T lower, T upper) {
   return (x >= lower && x <= upper);
 }
 
@@ -351,10 +367,10 @@ namespace {
 struct JsonParser final {
   /* State
    */
-    const char* str;
+  const char *str;
   const size_t str_len;
   size_t i;
-    string &err;
+  string *err;
   bool failed;
   const JsonParse strategy;
 
@@ -362,14 +378,11 @@ struct JsonParser final {
    *
    * Mark this parse as failed.
    */
-    Json fail(string &&msg) {
-        return fail(move(msg), Json());
-    }
+  Json fail(string &&msg) { return fail(move(msg), Json()); }
 
   template <typename T>
   T fail(string &&msg, const T err_ret) {
-        if (!failed)
-            err = std::move(msg);
+    if (!failed) *err = std::move(msg);
     failed = true;
     return err_ret;
   }
@@ -403,12 +416,14 @@ struct JsonParser final {
       } else if (str[i] == '*') {  // multiline comment
         i++;
         if (i > str_len - 2)
-            return fail("Unexpected end of input inside multi-line comment", false);
+          return fail("Unexpected end of input inside multi-line comment",
+                      false);
         // advance until closing tokens
-          while (!(str[i] == '*' && str[i+1] == '/')) {
+        while (!(str[i] == '*' && str[i + 1] == '/')) {
           i++;
           if (i > str_len - 2)
-              return fail("Unexpected end of input inside multi-line comment", false);
+            return fail("Unexpected end of input inside multi-line comment",
+                        false);
         }
         i += 2;
         comment_found = true;
@@ -437,14 +452,13 @@ struct JsonParser final {
 
   /* get_next_token()
    *
-     * Return the next non-whitespace character. If the end of the input is reached,
-     * flag an error and return 0.
+   * Return the next non-whitespace character. If the end of the input is
+   * reached, flag an error and return 0.
    */
   char get_next_token() {
     consume_garbage();
     if (failed) return char{0};
-        if (i == str_len)
-            return fail("Unexpected end of input", char{0});
+    if (i == str_len) return fail("Unexpected end of input", char{0});
 
     return str[i++];
   }
@@ -453,24 +467,23 @@ struct JsonParser final {
    *
    * Encode pt as UTF-8 and add it to out.
    */
-    void encode_utf8(long pt, string & out) {
-        if (pt < 0)
-            return;
+  void encode_utf8(int64_t pt, string* out) {
+    if (pt < 0) return;
 
     if (pt < 0x80) {
-            out += static_cast<char>(pt);
+      *out += static_cast<char>(pt);
     } else if (pt < 0x800) {
-            out += static_cast<char>((pt >> 6) | 0xC0);
-            out += static_cast<char>((pt & 0x3F) | 0x80);
+      *out += static_cast<char>((pt >> 6) | 0xC0);
+      *out += static_cast<char>((pt & 0x3F) | 0x80);
     } else if (pt < 0x10000) {
-            out += static_cast<char>((pt >> 12) | 0xE0);
-            out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
-            out += static_cast<char>((pt & 0x3F) | 0x80);
+      *out += static_cast<char>((pt >> 12) | 0xE0);
+      *out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
+      *out += static_cast<char>((pt & 0x3F) | 0x80);
     } else {
-            out += static_cast<char>((pt >> 18) | 0xF0);
-            out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
-            out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
-            out += static_cast<char>((pt & 0x3F) | 0x80);
+      *out += static_cast<char>((pt >> 18) | 0xF0);
+      *out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
+      *out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
+      *out += static_cast<char>((pt & 0x3F) | 0x80);
     }
   }
 
@@ -480,32 +493,30 @@ struct JsonParser final {
    */
   string parse_string() {
     string out;
-        long last_escaped_codepoint = -1;
+    int64_t last_escaped_codepoint = -1;
     while (true) {
-            if (i == str_len)
-                return fail("Unexpected end of input in string", "");
+      if (i == str_len) return fail("Unexpected end of input in string", "");
 
       char ch = str[i++];
 
       if (ch == '"') {
-                encode_utf8(last_escaped_codepoint, out);
+        encode_utf8(last_escaped_codepoint, &out);
         return out;
       }
 
-            if (in_range(ch, 0, 0x1f))
+      if (in_range<int64_t>(ch, 0, 0x1f))
         return fail("Unescaped " + esc(ch) + " in string", "");
 
       // The usual case: non-escaped characters
       if (ch != '\\') {
-                encode_utf8(last_escaped_codepoint, out);
+        encode_utf8(last_escaped_codepoint, &out);
         last_escaped_codepoint = -1;
         out += ch;
         continue;
       }
 
       // Handle escapes
-            if (i == str_len)
-                return fail("Unexpected end of input in string", "");
+      if (i == str_len) return fail("Unexpected end of input in string", "");
 
       ch = str[i++];
 
@@ -519,26 +530,30 @@ struct JsonParser final {
           return fail("Bad \\u escape: " + esc, "");
         }
         for (size_t j = 0; j < 4; j++) {
-                    if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F')
-                            && !in_range(esc[j], '0', '9'))
+          if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F') &&
+              !in_range(esc[j], '0', '9'))
             return fail("Bad \\u escape: " + esc, "");
         }
 
-                long codepoint = strtol(esc.data(), nullptr, 16);
-
-                // JSON specifies that characters outside the BMP shall be encoded as a pair
-                // of 4-hex-digit \u escapes encoding their surrogate pair components. Check
-                // whether we're in the middle of such a beast: the previous codepoint was an
-                // escaped lead (high) surrogate, and this is a trail (low) surrogate.
-                if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF)
-                        && in_range(codepoint, 0xDC00, 0xDFFF)) {
-                    // Reassemble the two surrogate pairs into one astral-plane character, per
-                    // the UTF-16 algorithm.
-                    encode_utf8((((last_escaped_codepoint - 0xD800) << 10)
-                                 | (codepoint - 0xDC00)) + 0x10000, out);
+        int64_t codepoint =
+            static_cast<int64_t>(strtol(esc.data(), nullptr, 16));
+
+        // JSON specifies that characters outside the BMP shall be encoded as a
+        // pair of 4-hex-digit \u escapes encoding their surrogate pair
+        // components. Check whether we're in the middle of such a beast: the
+        // previous codepoint was an escaped lead (high) surrogate, and this is
+        // a trail (low) surrogate.
+        if (in_range<int64_t>(last_escaped_codepoint, 0xD800, 0xDBFF) &&
+            in_range<int64_t>(codepoint, 0xDC00, 0xDFFF)) {
+          // Reassemble the two surrogate pairs into one astral-plane character,
+          // per the UTF-16 algorithm.
+          encode_utf8((((last_escaped_codepoint - 0xD800) << 10) |
+                       (codepoint - 0xDC00)) +
+                          0x10000,
+                      &out);
           last_escaped_codepoint = -1;
         } else {
-                    encode_utf8(last_escaped_codepoint, out);
+          encode_utf8(last_escaped_codepoint, &out);
           last_escaped_codepoint = codepoint;
         }
 
@@ -546,7 +561,7 @@ struct JsonParser final {
         continue;
       }
 
-            encode_utf8(last_escaped_codepoint, out);
+      encode_utf8(last_escaped_codepoint, &out);
       last_escaped_codepoint = -1;
 
       if (ch == 'b') {
@@ -574,8 +589,7 @@ struct JsonParser final {
   Json parse_number() {
     size_t start_pos = i;
 
-        if (str[i] == '-')
-            i++;
+    if (str[i] == '-') i++;
 
     // Integer part
     if (str[i] == '0') {
@@ -584,15 +598,15 @@ struct JsonParser final {
         return fail("Leading 0s not permitted in numbers");
     } else if (in_range(str[i], '1', '9')) {
       i++;
-            while (in_range(str[i], '0', '9'))
-                i++;
+      while (in_range(str[i], '0', '9')) i++;
     } else {
       return fail("Invalid " + esc(str[i]) + " in number");
     }
 
-        if (str[i] != '.' && str[i] != 'e' && str[i] != 'E'
-                && (i - start_pos) <= static_cast<size_t>(std::numeric_limits<int>::digits10)) {
-            return std::atoi(str + start_pos);
+    if (str[i] != '.' && str[i] != 'e' && str[i] != 'E' &&
+        (i - start_pos) <=
+            static_cast<size_t>(std::numeric_limits<int>::digits10)) {
+      return Json(std::atoi(str + start_pos));
     }
 
     // Decimal part
@@ -601,31 +615,28 @@ struct JsonParser final {
       if (!in_range(str[i], '0', '9'))
         return fail("At least one digit required in fractional part");
 
-            while (in_range(str[i], '0', '9'))
-                i++;
+      while (in_range(str[i], '0', '9')) i++;
     }
 
     // Exponent part
     if (str[i] == 'e' || str[i] == 'E') {
       i++;
 
-            if (str[i] == '+' || str[i] == '-')
-                i++;
+      if (str[i] == '+' || str[i] == '-') i++;
 
       if (!in_range(str[i], '0', '9'))
         return fail("At least one digit required in exponent");
 
-            while (in_range(str[i], '0', '9'))
-                i++;
+      while (in_range(str[i], '0', '9')) i++;
     }
 
-        return std::strtod(str + start_pos, nullptr);
+    return Json(std::strtod(str + start_pos, nullptr));
   }
 
   /* expect(str, res)
    *
-     * Expect that 'str' starts at the character that was just read. If it does, advance
-     * the input and return res. If not, flag an error.
+   * Expect that 'str' starts at the character that was just read. If it does,
+   * advance the input and return res. If not, flag an error.
    */
   Json expect(const string &expected, Json res) {
     CHECK_NE(i, 0)
@@ -649,81 +660,65 @@ struct JsonParser final {
     }
 
     char ch = get_next_token();
-        if (failed)
-            return Json();
+    if (failed) return Json();
 
     if (ch == '-' || (ch >= '0' && ch <= '9')) {
       i--;
       return parse_number();
     }
 
-        if (ch == 't')
-            return expect("true", true);
+    if (ch == 't') return expect("true", Json(true));
 
-        if (ch == 'f')
-            return expect("false", false);
+    if (ch == 'f') return expect("false", Json(false));
 
-        if (ch == 'n')
-            return expect("null", Json());
+    if (ch == 'n') return expect("null", Json());
 
-        if (ch == '"')
-            return parse_string();
+    if (ch == '"') return Json(parse_string());
 
     if (ch == '{') {
       map<string, Json> data;
       ch = get_next_token();
-            if (ch == '}')
-                return data;
+      if (ch == '}') return Json(data);
 
       while (1) {
-                if (ch != '"')
-                    return fail("Expected '\"' in object, got " + esc(ch));
+        if (ch != '"') return fail("Expected '\"' in object, got " + esc(ch));
 
         string key = parse_string();
-                if (failed)
-                    return Json();
+        if (failed) return Json();
 
         ch = get_next_token();
-                if (ch != ':')
-                    return fail("Expected ':' in object, got " + esc(ch));
+        if (ch != ':') return fail("Expected ':' in object, got " + esc(ch));
 
         data[std::move(key)] = parse_json(depth + 1);
-                if (failed)
-                    return Json();
+        if (failed) return Json();
 
         ch = get_next_token();
-                if (ch == '}')
-                    break;
-                if (ch != ',')
-                    return fail("Expected ',' in object, got " + esc(ch));
+        if (ch == '}') break;
+        if (ch != ',') return fail("Expected ',' in object, got " + esc(ch));
 
         ch = get_next_token();
       }
-            return data;
+      return Json(data);
     }
 
     if (ch == '[') {
       vector<Json> data;
       ch = get_next_token();
-            if (ch == ']')
-                return data;
+      if (ch == ']') return Json(data);
 
       while (1) {
         i--;
         data.push_back(parse_json(depth + 1));
-                if (failed)
-                    return Json();
+        if (failed) return Json();
 
         ch = get_next_token();
-                if (ch == ']')
-                    break;
-                if (ch != ',')
-                    return fail("Expected ',' in list, got " + esc(ch));
+        if (ch == ']') break;
+        if (ch != ',') return fail("Expected ',' in list, got " + esc(ch));
 
         ch = get_next_token();
         (void)ch;
       }
-            return data;
+      return Json(data);
     }
 
     return fail("Expected value, got " + esc(ch));
@@ -731,14 +726,13 @@ struct JsonParser final {
 };
 }  // namespace
 
-Json Json::parse(const string &in, string &err, JsonParse strategy) {
+Json Json::parse(const string &in, string *err, JsonParse strategy) {
   JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy};
   Json result = parser.parse_json(0);
 
   // Check for any trailing garbage
   parser.consume_garbage();
-    if (parser.failed)
-        return Json();
+  if (parser.failed) return Json();
   if (parser.i != in.size())
     return parser.fail("Unexpected trailing " + esc(in[parser.i]));
 
@@ -747,22 +741,19 @@ Json Json::parse(const string &in, string &err, JsonParse strategy) {
 
 // Documented in json11.hpp
 vector<Json> Json::parse_multi(const string &in,
-                               std::string::size_type &parser_stop_pos,
-                               string &err,
-                               JsonParse strategy) {
+                               std::string::size_type *parser_stop_pos,
+                               string *err, JsonParse strategy) {
   JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy};
-    parser_stop_pos = 0;
+  *parser_stop_pos = 0;
   vector<Json> json_vec;
   while (parser.i != in.size() && !parser.failed) {
     json_vec.push_back(parser.parse_json(0));
-        if (parser.failed)
-            break;
+    if (parser.failed) break;
 
     // Check for another object
     parser.consume_garbage();
-        if (parser.failed)
-            break;
-        parser_stop_pos = parser.i;
+    if (parser.failed) break;
+    *parser_stop_pos = parser.i;
   }
   return json_vec;
 }
@@ -771,15 +762,15 @@ vector<Json> Json::parse_multi(const string &in,
  * Shape-checking
  */
 
-bool Json::has_shape(const shape & types, string & err) const {
+bool Json::has_shape(const shape &types, string *err) const {
   if (!is_object()) {
-        err = "Expected JSON object, got " + dump();
+    *err = "Expected JSON object, got " + dump();
     return false;
   }
 
-    for (auto & item : types) {
+  for (auto &item : types) {
     if ((*this)[item.first].type() != item.second) {
-            err = "Bad type for " + item.first + " in " + dump();
+      *err = "Bad type for " + item.first + " in " + dump();
       return false;
     }
   }