jsoncpp: Revert "Code style: add missed explicit 'this->'"

Revert the part of commit 209daa20b2 (Code style: add missed explicit
'this->', 2021-01-05, v3.20.0-rc1~213^2) that updated third-party code.

3 files changed, 2411 insertions, 2883 deletions

diff --git a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
index 8362fc4..6eeba0e 100644
--- a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
+++ b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
@@ -2,88 +2,74 @@
 // Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
-// See file LICENSE for detail or copy at
-// http://jsoncpp.sourceforge.net/LICENSE
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-#  include <json/assertions.h>
-#  include <json/reader.h>
-#  include <json/value.h>
-
-#  include "json_tool.h"
+#include <json/assertions.h>
+#include <json/reader.h>
+#include <json/value.h>
+#include "json_tool.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
-#include <istream>
-#include <limits>
-#include <memory>
-#include <set>
-#include <sstream>
 #include <utility>
-
-#include <assert.h>
 #include <stdio.h>
+#include <assert.h>
 #include <string.h>
+#include <istream>
+#include <sstream>
+#include <memory>
+#include <set>
+#include <limits>
 
 #if defined(_MSC_VER)
-#  if !defined(WINCE) && defined(__STDC_SECURE_LIB__) &&                      \
-    _MSC_VER >= 1500 // VC++ 9.0 and above
-#    define snprintf sprintf_s
-#  elif _MSC_VER >= 1900 // VC++ 14.0 and above
-#    define snprintf std::snprintf
-#  else
-#    define snprintf _snprintf
-#  endif
+#if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above 
+#define snprintf sprintf_s
+#elif _MSC_VER >= 1900 // VC++ 14.0 and above
+#define snprintf std::snprintf
+#else
+#define snprintf _snprintf
+#endif
 #elif defined(__ANDROID__) || defined(__QNXNTO__)
-#  define snprintf snprintf
+#define snprintf snprintf
 #elif __cplusplus >= 201103L
-#  if !defined(__MINGW32__) && !defined(__CYGWIN__)
-#    define snprintf std::snprintf
-#  endif
+#if !defined(__MINGW32__) && !defined(__CYGWIN__)
+#define snprintf std::snprintf
+#endif
 #endif
 
 #if defined(__QNXNTO__)
-#  define sscanf std::sscanf
+#define sscanf std::sscanf
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
 // Disable warning about strdup being deprecated.
-#  pragma warning(disable : 4996)
+#pragma warning(disable : 4996)
 #endif
 
-// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
-// time to change the stack limit
+// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile time to change the stack limit
 #if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
-#  define JSONCPP_DEPRECATED_STACK_LIMIT 1000
+#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
 #endif
 
-static size_t const stackLimit_g =
-  JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
+static size_t const stackLimit_g = JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
 
 namespace Json {
 
 #if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
 typedef std::unique_ptr<CharReader> CharReaderPtr;
 #else
-typedef std::auto_ptr<CharReader> CharReaderPtr;
+typedef std::auto_ptr<CharReader>   CharReaderPtr;
 #endif
 
 // Implementation of class Features
 // ////////////////////////////////
 
 Features::Features()
-  : allowComments_(true)
-  , strictRoot_(false)
-  , allowDroppedNullPlaceholders_(false)
-  , allowNumericKeys_(false)
-{
-}
+    : allowComments_(true), strictRoot_(false),
+      allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
 
-Features Features::all()
-{
-  return Features();
-}
+Features Features::all() { return Features(); }
 
-Features Features::strictMode()
-{
+Features Features::strictMode() {
   Features features;
   features.allowComments_ = false;
   features.strictRoot_ = true;
@@ -95,8 +81,7 @@ Features Features::strictMode()
 // Implementation of class Reader
 // ////////////////////////////////
 
-bool Reader::containsNewLine(Reader::Location begin, Reader::Location end)
-{
+bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
   for (; begin < end; ++begin)
     if (*begin == '\n' || *begin == '\r')
       return true;
@@ -107,44 +92,24 @@ bool Reader::containsNewLine(Reader::Location begin, Reader::Location end)
 // //////////////////////////////////////////////////////////////////
 
 Reader::Reader()
-  : errors_()
-  , document_()
-  , begin_()
-  , end_()
-  , current_()
-  , lastValueEnd_()
-  , lastValue_()
-  , commentsBefore_()
-  , features_(Features::all())
-  , collectComments_()
-{
-}
+    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
+      lastValue_(), commentsBefore_(), features_(Features::all()),
+      collectComments_() {}
 
 Reader::Reader(const Features& features)
-  : errors_()
-  , document_()
-  , begin_()
-  , end_()
-  , current_()
-  , lastValueEnd_()
-  , lastValue_()
-  , commentsBefore_()
-  , features_(features)
-  , collectComments_()
-{
+    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
+      lastValue_(), commentsBefore_(), features_(features), collectComments_() {
 }
 
-bool Reader::parse(const std::string& document, Value& root,
-                   bool collectComments)
-{
-  this->document_.assign(document.begin(), document.end());
-  const char* begin = this->document_.c_str();
-  const char* end = begin + this->document_.length();
-  return this->parse(begin, end, root, collectComments);
+bool
+Reader::parse(const std::string& document, Value& root, bool collectComments) {
+  document_.assign(document.begin(), document.end());
+  const char* begin = document_.c_str();
+  const char* end = begin + document_.length();
+  return parse(begin, end, root, collectComments);
 }
 
-bool Reader::parse(std::istream& sin, Value& root, bool collectComments)
-{
+bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
   // std::istream_iterator<char> begin(sin);
   // std::istream_iterator<char> end;
   // Those would allow streamed input from a file, if parse() were a
@@ -154,263 +119,257 @@ bool Reader::parse(std::istream& sin, Value& root, bool collectComments)
   // create an extra copy.
   JSONCPP_STRING doc;
   std::getline(sin, doc, (char)EOF);
-  return this->parse(doc.data(), doc.data() + doc.size(), root,
-                     collectComments);
+  return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
 }
 
-bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
-                   bool collectComments)
-{
-  if (!this->features_.allowComments_) {
+bool Reader::parse(const char* beginDoc,
+                   const char* endDoc,
+                   Value& root,
+                   bool collectComments) {
+  if (!features_.allowComments_) {
     collectComments = false;
   }
 
-  this->begin_ = beginDoc;
-  this->end_ = endDoc;
-  this->collectComments_ = collectComments;
-  this->current_ = this->begin_;
-  this->lastValueEnd_ = 0;
-  this->lastValue_ = 0;
-  this->commentsBefore_.clear();
-  this->errors_.clear();
-  while (!this->nodes_.empty())
-    this->nodes_.pop();
-  this->nodes_.push(&root);
-
-  bool successful = this->readValue();
+  begin_ = beginDoc;
+  end_ = endDoc;
+  collectComments_ = collectComments;
+  current_ = begin_;
+  lastValueEnd_ = 0;
+  lastValue_ = 0;
+  commentsBefore_.clear();
+  errors_.clear();
+  while (!nodes_.empty())
+    nodes_.pop();
+  nodes_.push(&root);
+
+  bool successful = readValue();
   Token token;
-  this->skipCommentTokens(token);
-  if (this->collectComments_ && !this->commentsBefore_.empty())
-    root.setComment(this->commentsBefore_, commentAfter);
-  if (this->features_.strictRoot_) {
+  skipCommentTokens(token);
+  if (collectComments_ && !commentsBefore_.empty())
+    root.setComment(commentsBefore_, commentAfter);
+  if (features_.strictRoot_) {
     if (!root.isArray() && !root.isObject()) {
-      // Set error location to start of doc, ideally should be first token
-      // found in doc
+      // Set error location to start of doc, ideally should be first token found
+      // in doc
       token.type_ = tokenError;
       token.start_ = beginDoc;
       token.end_ = endDoc;
-      this->addError(
-        "A valid JSON document must be either an array or an object value.",
-        token);
+      addError(
+          "A valid JSON document must be either an array or an object value.",
+          token);
       return false;
     }
   }
   return successful;
 }
 
-bool Reader::readValue()
-{
+bool Reader::readValue() {
   // readValue() may call itself only if it calls readObject() or ReadArray().
-  // These methods execute nodes_.push() just before and nodes_.pop)() just
-  // after calling readValue(). parse() executes one nodes_.push(), so >
-  // instead of >=.
-  if (this->nodes_.size() > stackLimit_g)
-    throwRuntimeError("Exceeded stackLimit in readValue().");
+  // These methods execute nodes_.push() just before and nodes_.pop)() just after calling readValue(). 
+  // parse() executes one nodes_.push(), so > instead of >=.
+  if (nodes_.size() > stackLimit_g) throwRuntimeError("Exceeded stackLimit in readValue().");
 
   Token token;
-  this->skipCommentTokens(token);
+  skipCommentTokens(token);
   bool successful = true;
 
-  if (this->collectComments_ && !this->commentsBefore_.empty()) {
-    this->currentValue().setComment(this->commentsBefore_, commentBefore);
-    this->commentsBefore_.clear();
+  if (collectComments_ && !commentsBefore_.empty()) {
+    currentValue().setComment(commentsBefore_, commentBefore);
+    commentsBefore_.clear();
   }
 
   switch (token.type_) {
-    case tokenObjectBegin:
-      successful = this->readObject(token);
-      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
-      break;
-    case tokenArrayBegin:
-      successful = this->readArray(token);
-      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
-      break;
-    case tokenNumber:
-      successful = this->decodeNumber(token);
-      break;
-    case tokenString:
-      successful = this->decodeString(token);
-      break;
-    case tokenTrue: {
-      Value v(true);
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenFalse: {
-      Value v(false);
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenNull: {
+  case tokenObjectBegin:
+    successful = readObject(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenArrayBegin:
+    successful = readArray(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenNumber:
+    successful = decodeNumber(token);
+    break;
+  case tokenString:
+    successful = decodeString(token);
+    break;
+  case tokenTrue:
+    {
+    Value v(true);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenFalse:
+    {
+    Value v(false);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenNull:
+    {
+    Value v;
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenArraySeparator:
+  case tokenObjectEnd:
+  case tokenArrayEnd:
+    if (features_.allowDroppedNullPlaceholders_) {
+      // "Un-read" the current token and mark the current value as a null
+      // token.
+      current_--;
       Value v;
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenArraySeparator:
-    case tokenObjectEnd:
-    case tokenArrayEnd:
-      if (this->features_.allowDroppedNullPlaceholders_) {
-        // "Un-read" the current token and mark the current value as a null
-        // token.
-        this->current_--;
-        Value v;
-        this->currentValue().swapPayload(v);
-        this->currentValue().setOffsetStart(this->current_ - this->begin_ - 1);
-        this->currentValue().setOffsetLimit(this->current_ - this->begin_);
-        break;
-      } // Else, fall through...
-    default:
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-      return this->addError("Syntax error: value, object or array expected.",
-                            token);
+      currentValue().swapPayload(v);
+      currentValue().setOffsetStart(current_ - begin_ - 1);
+      currentValue().setOffsetLimit(current_ - begin_);
+      break;
+    } // Else, fall through...
+  default:
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    return addError("Syntax error: value, object or array expected.", token);
   }
 
-  if (this->collectComments_) {
-    this->lastValueEnd_ = this->current_;
-    this->lastValue_ = &this->currentValue();
+  if (collectComments_) {
+    lastValueEnd_ = current_;
+    lastValue_ = &currentValue();
   }
 
   return successful;
 }
 
-void Reader::skipCommentTokens(Token& token)
-{
-  if (this->features_.allowComments_) {
+void Reader::skipCommentTokens(Token& token) {
+  if (features_.allowComments_) {
     do {
-      this->readToken(token);
+      readToken(token);
     } while (token.type_ == tokenComment);
   } else {
-    this->readToken(token);
+    readToken(token);
   }
 }
 
-bool Reader::readToken(Token& token)
-{
-  this->skipSpaces();
-  token.start_ = this->current_;
-  Char c = this->getNextChar();
+bool Reader::readToken(Token& token) {
+  skipSpaces();
+  token.start_ = current_;
+  Char c = getNextChar();
   bool ok = true;
   switch (c) {
-    case '{':
-      token.type_ = tokenObjectBegin;
-      break;
-    case '}':
-      token.type_ = tokenObjectEnd;
-      break;
-    case '[':
-      token.type_ = tokenArrayBegin;
-      break;
-    case ']':
-      token.type_ = tokenArrayEnd;
-      break;
-    case '"':
-      token.type_ = tokenString;
-      ok = this->readString();
-      break;
-    case '/':
-      token.type_ = tokenComment;
-      ok = this->readComment();
-      break;
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-':
-      token.type_ = tokenNumber;
-      this->readNumber();
-      break;
-    case 't':
-      token.type_ = tokenTrue;
-      ok = this->match("rue", 3);
-      break;
-    case 'f':
-      token.type_ = tokenFalse;
-      ok = this->match("alse", 4);
-      break;
-    case 'n':
-      token.type_ = tokenNull;
-      ok = this->match("ull", 3);
-      break;
-    case ',':
-      token.type_ = tokenArraySeparator;
-      break;
-    case ':':
-      token.type_ = tokenMemberSeparator;
-      break;
-    case 0:
-      token.type_ = tokenEndOfStream;
-      break;
-    default:
-      ok = false;
-      break;
+  case '{':
+    token.type_ = tokenObjectBegin;
+    break;
+  case '}':
+    token.type_ = tokenObjectEnd;
+    break;
+  case '[':
+    token.type_ = tokenArrayBegin;
+    break;
+  case ']':
+    token.type_ = tokenArrayEnd;
+    break;
+  case '"':
+    token.type_ = tokenString;
+    ok = readString();
+    break;
+  case '/':
+    token.type_ = tokenComment;
+    ok = readComment();
+    break;
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+  case '-':
+    token.type_ = tokenNumber;
+    readNumber();
+    break;
+  case 't':
+    token.type_ = tokenTrue;
+    ok = match("rue", 3);
+    break;
+  case 'f':
+    token.type_ = tokenFalse;
+    ok = match("alse", 4);
+    break;
+  case 'n':
+    token.type_ = tokenNull;
+    ok = match("ull", 3);
+    break;
+  case ',':
+    token.type_ = tokenArraySeparator;
+    break;
+  case ':':
+    token.type_ = tokenMemberSeparator;
+    break;
+  case 0:
+    token.type_ = tokenEndOfStream;
+    break;
+  default:
+    ok = false;
+    break;
   }
   if (!ok)
     token.type_ = tokenError;
-  token.end_ = this->current_;
+  token.end_ = current_;
   return true;
 }
 
-void Reader::skipSpaces()
-{
-  while (this->current_ != this->end_) {
-    Char c = *this->current_;
+void Reader::skipSpaces() {
+  while (current_ != end_) {
+    Char c = *current_;
     if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
-      ++this->current_;
+      ++current_;
     else
       break;
   }
 }
 
-bool Reader::match(Location pattern, int patternLength)
-{
-  if (this->end_ - this->current_ < patternLength)
+bool Reader::match(Location pattern, int patternLength) {
+  if (end_ - current_ < patternLength)
     return false;
   int index = patternLength;
   while (index--)
-    if (this->current_[index] != pattern[index])
+    if (current_[index] != pattern[index])
       return false;
-  this->current_ += patternLength;
+  current_ += patternLength;
   return true;
 }
 
-bool Reader::readComment()
-{
-  Location commentBegin = this->current_ - 1;
-  Char c = this->getNextChar();
+bool Reader::readComment() {
+  Location commentBegin = current_ - 1;
+  Char c = getNextChar();
   bool successful = false;
   if (c == '*')
-    successful = this->readCStyleComment();
+    successful = readCStyleComment();
   else if (c == '/')
-    successful = this->readCppStyleComment();
+    successful = readCppStyleComment();
   if (!successful)
     return false;
 
-  if (this->collectComments_) {
+  if (collectComments_) {
     CommentPlacement placement = commentBefore;
-    if (this->lastValueEnd_ &&
-        !containsNewLine(this->lastValueEnd_, commentBegin)) {
-      if (c != '*' || !containsNewLine(commentBegin, this->current_))
+    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+      if (c != '*' || !containsNewLine(commentBegin, current_))
         placement = commentAfterOnSameLine;
     }
 
-    this->addComment(commentBegin, this->current_, placement);
+    addComment(commentBegin, current_, placement);
   }
   return true;
 }
 
-JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin,
-                                    Reader::Location end)
-{
+JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
   JSONCPP_STRING normalized;
   normalized.reserve(static_cast<size_t>(end - begin));
   Reader::Location current = begin;
@@ -418,8 +377,8 @@ JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin,
     char c = *current++;
     if (c == '\r') {
       if (current != end && *current == '\n')
-        // convert dos EOL
-        ++current;
+         // convert dos EOL
+         ++current;
       // convert Mac EOL
       normalized += '\n';
     } else {
@@ -429,39 +388,36 @@ JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin,
   return normalized;
 }
 
-void Reader::addComment(Location begin, Location end,
-                        CommentPlacement placement)
-{
-  assert(this->collectComments_);
+void
+Reader::addComment(Location begin, Location end, CommentPlacement placement) {
+  assert(collectComments_);
   const JSONCPP_STRING& normalized = normalizeEOL(begin, end);
   if (placement == commentAfterOnSameLine) {
-    assert(this->lastValue_ != 0);
-    this->lastValue_->setComment(normalized, placement);
+    assert(lastValue_ != 0);
+    lastValue_->setComment(normalized, placement);
   } else {
-    this->commentsBefore_ += normalized;
+    commentsBefore_ += normalized;
   }
 }
 
-bool Reader::readCStyleComment()
-{
-  while ((this->current_ + 1) < this->end_) {
-    Char c = this->getNextChar();
-    if (c == '*' && *this->current_ == '/')
+bool Reader::readCStyleComment() {
+  while ((current_ + 1) < end_) {
+    Char c = getNextChar();
+    if (c == '*' && *current_ == '/')
       break;
   }
-  return this->getNextChar() == '/';
+  return getNextChar() == '/';
 }
 
-bool Reader::readCppStyleComment()
-{
-  while (this->current_ != this->end_) {
-    Char c = this->getNextChar();
+bool Reader::readCppStyleComment() {
+  while (current_ != end_) {
+    Char c = getNextChar();
     if (c == '\n')
       break;
     if (c == '\r') {
       // Consume DOS EOL. It will be normalized in addComment.
-      if (this->current_ != this->end_ && *this->current_ == '\n')
-        this->getNextChar();
+      if (current_ != end_ && *current_ == '\n')
+        getNextChar();
       // Break on Moc OS 9 EOL.
       break;
     }
@@ -469,132 +425,127 @@ bool Reader::readCppStyleComment()
   return true;
 }
 
-void Reader::readNumber()
-{
-  const char* p = this->current_;
+void Reader::readNumber() {
+  const char *p = current_;
   char c = '0'; // stopgap for already consumed character
   // integral part
   while (c >= '0' && c <= '9')
-    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+    c = (current_ = p) < end_ ? *p++ : '\0';
   // fractional part
   if (c == '.') {
-    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+    c = (current_ = p) < end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+      c = (current_ = p) < end_ ? *p++ : '\0';
   }
   // exponential part
   if (c == 'e' || c == 'E') {
-    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+    c = (current_ = p) < end_ ? *p++ : '\0';
     if (c == '+' || c == '-')
-      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+      c = (current_ = p) < end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+      c = (current_ = p) < end_ ? *p++ : '\0';
   }
 }
 
-bool Reader::readString()
-{
+bool Reader::readString() {
   Char c = '\0';
-  while (this->current_ != this->end_) {
-    c = this->getNextChar();
+  while (current_ != end_) {
+    c = getNextChar();
     if (c == '\\')
-      this->getNextChar();
+      getNextChar();
     else if (c == '"')
       break;
   }
   return c == '"';
 }
 
-bool Reader::readObject(Token& tokenStart)
-{
+bool Reader::readObject(Token& tokenStart) {
   Token tokenName;
   JSONCPP_STRING name;
   Value init(objectValue);
-  this->currentValue().swapPayload(init);
-  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
-  while (this->readToken(tokenName)) {
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(tokenStart.start_ - begin_);
+  while (readToken(tokenName)) {
     bool initialTokenOk = true;
     while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = this->readToken(tokenName);
+      initialTokenOk = readToken(tokenName);
     if (!initialTokenOk)
       break;
     if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
       return true;
     name.clear();
     if (tokenName.type_ == tokenString) {
-      if (!this->decodeString(tokenName, name))
-        return this->recoverFromError(tokenObjectEnd);
-    } else if (tokenName.type_ == tokenNumber &&
-               this->features_.allowNumericKeys_) {
+      if (!decodeString(tokenName, name))
+        return recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
       Value numberName;
-      if (!this->decodeNumber(tokenName, numberName))
-        return this->recoverFromError(tokenObjectEnd);
+      if (!decodeNumber(tokenName, numberName))
+        return recoverFromError(tokenObjectEnd);
       name = JSONCPP_STRING(numberName.asCString());
     } else {
       break;
     }
 
     Token colon;
-    if (!this->readToken(colon) || colon.type_ != tokenMemberSeparator) {
-      return this->addErrorAndRecover("Missing ':' after object member name",
-                                      colon, tokenObjectEnd);
+    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return addErrorAndRecover(
+          "Missing ':' after object member name", colon, tokenObjectEnd);
     }
-    Value& value = this->currentValue()[name];
-    this->nodes_.push(&value);
-    bool ok = this->readValue();
-    this->nodes_.pop();
+    Value& value = currentValue()[name];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
     if (!ok) // error already set
-      return this->recoverFromError(tokenObjectEnd);
+      return recoverFromError(tokenObjectEnd);
 
     Token comma;
-    if (!this->readToken(comma) ||
+    if (!readToken(comma) ||
         (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
          comma.type_ != tokenComment)) {
-      return this->addErrorAndRecover(
-        "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
+      return addErrorAndRecover(
+          "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
     }
     bool finalizeTokenOk = true;
     while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = this->readToken(comma);
+      finalizeTokenOk = readToken(comma);
     if (comma.type_ == tokenObjectEnd)
       return true;
   }
-  return this->addErrorAndRecover("Missing '}' or object member name",
-                                  tokenName, tokenObjectEnd);
+  return addErrorAndRecover(
+      "Missing '}' or object member name", tokenName, tokenObjectEnd);
 }
 
-bool Reader::readArray(Token& tokenStart)
-{
+bool Reader::readArray(Token& tokenStart) {
   Value init(arrayValue);
-  this->currentValue().swapPayload(init);
-  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
-  this->skipSpaces();
-  if (this->current_ != this->end_ && *this->current_ == ']') // empty array
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(tokenStart.start_ - begin_);
+  skipSpaces();
+  if (current_ != end_ && *current_ == ']') // empty array
   {
     Token endArray;
-    this->readToken(endArray);
+    readToken(endArray);
     return true;
   }
   int index = 0;
   for (;;) {
-    Value& value = this->currentValue()[index++];
-    this->nodes_.push(&value);
-    bool ok = this->readValue();
-    this->nodes_.pop();
+    Value& value = currentValue()[index++];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
     if (!ok) // error already set
-      return this->recoverFromError(tokenArrayEnd);
+      return recoverFromError(tokenArrayEnd);
 
     Token token;
     // Accept Comment after last item in the array.
-    ok = this->readToken(token);
+    ok = readToken(token);
     while (token.type_ == tokenComment && ok) {
-      ok = this->readToken(token);
+      ok = readToken(token);
     }
     bool badTokenType =
-      (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+        (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
     if (!ok || badTokenType) {
-      return this->addErrorAndRecover(
-        "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
+      return addErrorAndRecover(
+          "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
     }
     if (token.type_ == tokenArrayEnd)
       break;
@@ -602,19 +553,17 @@ bool Reader::readArray(Token& tokenStart)
   return true;
 }
 
-bool Reader::decodeNumber(Token& token)
-{
+bool Reader::decodeNumber(Token& token) {
   Value decoded;
-  if (!this->decodeNumber(token, decoded))
+  if (!decodeNumber(token, decoded))
     return false;
-  this->currentValue().swapPayload(decoded);
-  this->currentValue().setOffsetStart(token.start_ - this->begin_);
-  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-bool Reader::decodeNumber(Token& token, Value& decoded)
-{
+bool Reader::decodeNumber(Token& token, Value& decoded) {
   // Attempts to parse the number as an integer. If the number is
   // larger than the maximum supported value of an integer then
   // we decode the number as a double.
@@ -622,17 +571,16 @@ bool Reader::decodeNumber(Token& token, Value& decoded)
   bool isNegative = *current == '-';
   if (isNegative)
     ++current;
-  // TODO: Help the compiler do the div and mod at compile time or get rid of
-  // them.
-  Value::LargestUInt maxIntegerValue = isNegative
-    ? Value::LargestUInt(Value::maxLargestInt) + 1
-    : Value::maxLargestUInt;
+  // TODO: Help the compiler do the div and mod at compile time or get rid of them.
+  Value::LargestUInt maxIntegerValue =
+      isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
+                 : Value::maxLargestUInt;
   Value::LargestUInt threshold = maxIntegerValue / 10;
   Value::LargestUInt value = 0;
   while (current < token.end_) {
     Char c = *current++;
     if (c < '0' || c > '9')
-      return this->decodeDouble(token, decoded);
+      return decodeDouble(token, decoded);
     Value::UInt digit(static_cast<Value::UInt>(c - '0'));
     if (value >= threshold) {
       // We've hit or exceeded the max value divided by 10 (rounded down). If
@@ -641,7 +589,7 @@ bool Reader::decodeNumber(Token& token, Value& decoded)
       // Otherwise treat this number as a double to avoid overflow.
       if (value > threshold || current != token.end_ ||
           digit > maxIntegerValue % 10) {
-        return this->decodeDouble(token, decoded);
+        return decodeDouble(token, decoded);
       }
     }
     value = value * 10 + digit;
@@ -657,44 +605,40 @@ bool Reader::decodeNumber(Token& token, Value& decoded)
   return true;
 }
 
-bool Reader::decodeDouble(Token& token)
-{
+bool Reader::decodeDouble(Token& token) {
   Value decoded;
-  if (!this->decodeDouble(token, decoded))
+  if (!decodeDouble(token, decoded))
     return false;
-  this->currentValue().swapPayload(decoded);
-  this->currentValue().setOffsetStart(token.start_ - this->begin_);
-  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-bool Reader::decodeDouble(Token& token, Value& decoded)
-{
+bool Reader::decodeDouble(Token& token, Value& decoded) {
   double value = 0;
   JSONCPP_STRING buffer(token.start_, token.end_);
   JSONCPP_ISTRINGSTREAM is(buffer);
   if (!(is >> value))
-    return this->addError("'" + JSONCPP_STRING(token.start_, token.end_) +
-                            "' is not a number.",
-                          token);
+    return addError("'" + JSONCPP_STRING(token.start_, token.end_) +
+                        "' is not a number.",
+                    token);
   decoded = value;
   return true;
 }
 
-bool Reader::decodeString(Token& token)
-{
+bool Reader::decodeString(Token& token) {
   JSONCPP_STRING decoded_string;
-  if (!this->decodeString(token, decoded_string))
+  if (!decodeString(token, decoded_string))
     return false;
   Value decoded(decoded_string);
-  this->currentValue().swapPayload(decoded);
-  this->currentValue().setOffsetStart(token.start_ - this->begin_);
-  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded)
-{
+bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded) {
   decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
   Location current = token.start_ + 1; // skip '"'
   Location end = token.end_ - 1;       // do not include '"'
@@ -704,43 +648,41 @@ bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded)
       break;
     else if (c == '\\') {
       if (current == end)
-        return this->addError("Empty escape sequence in string", token,
-                              current);
+        return addError("Empty escape sequence in string", token, current);
       Char escape = *current++;
       switch (escape) {
-        case '"':
-          decoded += '"';
-          break;
-        case '/':
-          decoded += '/';
-          break;
-        case '\\':
-          decoded += '\\';
-          break;
-        case 'b':
-          decoded += '\b';
-          break;
-        case 'f':
-          decoded += '\f';
-          break;
-        case 'n':
-          decoded += '\n';
-          break;
-        case 'r':
-          decoded += '\r';
-          break;
-        case 't':
-          decoded += '\t';
-          break;
-        case 'u': {
-          unsigned int unicode;
-          if (!this->decodeUnicodeCodePoint(token, current, end, unicode))
-            return false;
-          decoded += codePointToUTF8(unicode);
-        } break;
-        default:
-          return this->addError("Bad escape sequence in string", token,
-                                current);
+      case '"':
+        decoded += '"';
+        break;
+      case '/':
+        decoded += '/';
+        break;
+      case '\\':
+        decoded += '\\';
+        break;
+      case 'b':
+        decoded += '\b';
+        break;
+      case 'f':
+        decoded += '\f';
+        break;
+      case 'n':
+        decoded += '\n';
+        break;
+      case 'r':
+        decoded += '\r';
+        break;
+      case 't':
+        decoded += '\t';
+        break;
+      case 'u': {
+        unsigned int unicode;
+        if (!decodeUnicodeCodePoint(token, current, end, unicode))
+          return false;
+        decoded += codePointToUTF8(unicode);
+      } break;
+      default:
+        return addError("Bad escape sequence in string", token, current);
       }
     } else {
       decoded += c;
@@ -749,43 +691,44 @@ bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded)
   return true;
 }
 
-bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
-                                    Location end, unsigned int& unicode)
-{
+bool Reader::decodeUnicodeCodePoint(Token& token,
+                                    Location& current,
+                                    Location end,
+                                    unsigned int& unicode) {
 
-  if (!this->decodeUnicodeEscapeSequence(token, current, end, unicode))
+  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
     return false;
   if (unicode >= 0xD800 && unicode <= 0xDBFF) {
     // surrogate pairs
     if (end - current < 6)
-      return this->addError(
-        "additional six characters expected to parse unicode surrogate pair.",
-        token, current);
+      return addError(
+          "additional six characters expected to parse unicode surrogate pair.",
+          token,
+          current);
     unsigned int surrogatePair;
     if (*(current++) == '\\' && *(current++) == 'u') {
-      if (this->decodeUnicodeEscapeSequence(token, current, end,
-                                            surrogatePair)) {
-        unicode =
-          0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
+        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
       } else
         return false;
     } else
-      return this->addError(
-        "expecting another \\u token to begin the second half of "
-        "a unicode surrogate pair",
-        token, current);
+      return addError("expecting another \\u token to begin the second half of "
+                      "a unicode surrogate pair",
+                      token,
+                      current);
   }
   return true;
 }
 
-bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
+bool Reader::decodeUnicodeEscapeSequence(Token& token,
+                                         Location& current,
                                          Location end,
-                                         unsigned int& ret_unicode)
-{
+                                         unsigned int& ret_unicode) {
   if (end - current < 4)
-    return this->addError(
-      "Bad unicode escape sequence in string: four digits expected.", token,
-      current);
+    return addError(
+        "Bad unicode escape sequence in string: four digits expected.",
+        token,
+        current);
   int unicode = 0;
   for (int index = 0; index < 4; ++index) {
     Char c = *current++;
@@ -797,65 +740,60 @@ bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
     else if (c >= 'A' && c <= 'F')
       unicode += c - 'A' + 10;
     else
-      return this->addError(
-        "Bad unicode escape sequence in string: hexadecimal digit expected.",
-        token, current);
+      return addError(
+          "Bad unicode escape sequence in string: hexadecimal digit expected.",
+          token,
+          current);
   }
   ret_unicode = static_cast<unsigned int>(unicode);
   return true;
 }
 
-bool Reader::addError(const JSONCPP_STRING& message, Token& token,
-                      Location extra)
-{
+bool
+Reader::addError(const JSONCPP_STRING& message, Token& token, Location extra) {
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = extra;
-  this->errors_.push_back(info);
+  errors_.push_back(info);
   return false;
 }
 
-bool Reader::recoverFromError(TokenType skipUntilToken)
-{
-  size_t const errorCount = this->errors_.size();
+bool Reader::recoverFromError(TokenType skipUntilToken) {
+  size_t const errorCount = errors_.size();
   Token skip;
   for (;;) {
-    if (!this->readToken(skip))
-      this->errors_.resize(errorCount); // discard errors caused by recovery
+    if (!readToken(skip))
+      errors_.resize(errorCount); // discard errors caused by recovery
     if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
       break;
   }
-  this->errors_.resize(errorCount);
+  errors_.resize(errorCount);
   return false;
 }
 
-bool Reader::addErrorAndRecover(const JSONCPP_STRING& message, Token& token,
-                                TokenType skipUntilToken)
-{
-  this->addError(message, token);
-  return this->recoverFromError(skipUntilToken);
+bool Reader::addErrorAndRecover(const JSONCPP_STRING& message,
+                                Token& token,
+                                TokenType skipUntilToken) {
+  addError(message, token);
+  return recoverFromError(skipUntilToken);
 }
 
-Value& Reader::currentValue()
-{
-  return *(this->nodes_.top());
-}
+Value& Reader::currentValue() { return *(nodes_.top()); }
 
-Reader::Char Reader::getNextChar()
-{
-  if (this->current_ == this->end_)
+Reader::Char Reader::getNextChar() {
+  if (current_ == end_)
     return 0;
-  return *this->current_++;
+  return *current_++;
 }
 
-void Reader::getLocationLineAndColumn(Location location, int& line,
-                                      int& column) const
-{
-  Location current = this->begin_;
+void Reader::getLocationLineAndColumn(Location location,
+                                      int& line,
+                                      int& column) const {
+  Location current = begin_;
   Location lastLineStart = current;
   line = 0;
-  while (current < location && current != this->end_) {
+  while (current < location && current != end_) {
     Char c = *current++;
     if (c == '\r') {
       if (*current == '\n')
@@ -872,96 +810,91 @@ void Reader::getLocationLineAndColumn(Location location, int& line,
   ++line;
 }
 
-JSONCPP_STRING Reader::getLocationLineAndColumn(Location location) const
-{
+JSONCPP_STRING Reader::getLocationLineAndColumn(Location location) const {
   int line, column;
-  this->getLocationLineAndColumn(location, line, column);
+  getLocationLineAndColumn(location, line, column);
   char buffer[18 + 16 + 16 + 1];
   snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
   return buffer;
 }
 
 // Deprecated. Preserved for backward compatibility
-JSONCPP_STRING Reader::getFormatedErrorMessages() const
-{
-  return this->getFormattedErrorMessages();
+JSONCPP_STRING Reader::getFormatedErrorMessages() const {
+  return getFormattedErrorMessages();
 }
 
-JSONCPP_STRING Reader::getFormattedErrorMessages() const
-{
+JSONCPP_STRING Reader::getFormattedErrorMessages() const {
   JSONCPP_STRING formattedMessage;
-  for (Errors::const_iterator itError = this->errors_.begin();
-       itError != this->errors_.end(); ++itError) {
+  for (Errors::const_iterator itError = errors_.begin();
+       itError != errors_.end();
+       ++itError) {
     const ErrorInfo& error = *itError;
     formattedMessage +=
-      "* " + this->getLocationLineAndColumn(error.token_.start_) + "\n";
+        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
     formattedMessage += "  " + error.message_ + "\n";
     if (error.extra_)
-      formattedMessage += "See " +
-        this->getLocationLineAndColumn(error.extra_) + " for detail.\n";
+      formattedMessage +=
+          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
   }
   return formattedMessage;
 }
 
-std::vector<Reader::StructuredError> Reader::getStructuredErrors() const
-{
+std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
   std::vector<Reader::StructuredError> allErrors;
-  for (Errors::const_iterator itError = this->errors_.begin();
-       itError != this->errors_.end(); ++itError) {
+  for (Errors::const_iterator itError = errors_.begin();
+       itError != errors_.end();
+       ++itError) {
     const ErrorInfo& error = *itError;
     Reader::StructuredError structured;
-    structured.offset_start = error.token_.start_ - this->begin_;
-    structured.offset_limit = error.token_.end_ - this->begin_;
+    structured.offset_start = error.token_.start_ - begin_;
+    structured.offset_limit = error.token_.end_ - begin_;
     structured.message = error.message_;
     allErrors.push_back(structured);
   }
   return allErrors;
 }
 
-bool Reader::pushError(const Value& value, const JSONCPP_STRING& message)
-{
-  ptrdiff_t const length = this->end_ - this->begin_;
-  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
+bool Reader::pushError(const Value& value, const JSONCPP_STRING& message) {
+  ptrdiff_t const length = end_ - begin_;
+  if(value.getOffsetStart() > length
+    || value.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = this->begin_ + value.getOffsetStart();
-  token.end_ = this->end_ + value.getOffsetLimit();
+  token.start_ = begin_ + value.getOffsetStart();
+  token.end_ = end_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = 0;
-  this->errors_.push_back(info);
+  errors_.push_back(info);
   return true;
 }
 
-bool Reader::pushError(const Value& value, const JSONCPP_STRING& message,
-                       const Value& extra)
-{
-  ptrdiff_t const length = this->end_ - this->begin_;
-  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
-      extra.getOffsetLimit() > length)
+bool Reader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra) {
+  ptrdiff_t const length = end_ - begin_;
+  if(value.getOffsetStart() > length
+    || value.getOffsetLimit() > length
+    || extra.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = this->begin_ + value.getOffsetStart();
-  token.end_ = this->begin_ + value.getOffsetLimit();
+  token.start_ = begin_ + value.getOffsetStart();
+  token.end_ = begin_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
-  info.extra_ = this->begin_ + extra.getOffsetStart();
-  this->errors_.push_back(info);
+  info.extra_ = begin_ + extra.getOffsetStart();
+  errors_.push_back(info);
   return true;
 }
 
-bool Reader::good() const
-{
-  return !this->errors_.size();
+bool Reader::good() const {
+  return !errors_.size();
 }
 
 // exact copy of Features
-class OurFeatures
-{
+class OurFeatures {
 public:
   static OurFeatures all();
   bool allowComments_;
@@ -973,48 +906,43 @@ public:
   bool rejectDupKeys_;
   bool allowSpecialFloats_;
   int stackLimit_;
-}; // OurFeatures
+};  // OurFeatures
 
 // exact copy of Implementation of class Features
 // ////////////////////////////////
 
-OurFeatures OurFeatures::all()
-{
-  return OurFeatures();
-}
+OurFeatures OurFeatures::all() { return OurFeatures(); }
 
 // Implementation of class Reader
 // ////////////////////////////////
 
 // exact copy of Reader, renamed to OurReader
-class OurReader
-{
+class OurReader {
 public:
   typedef char Char;
   typedef const Char* Location;
-  struct StructuredError
-  {
+  struct StructuredError {
     ptrdiff_t offset_start;
     ptrdiff_t offset_limit;
     JSONCPP_STRING message;
   };
 
   OurReader(OurFeatures const& features);
-  bool parse(const char* beginDoc, const char* endDoc, Value& root,
+  bool parse(const char* beginDoc,
+             const char* endDoc,
+             Value& root,
              bool collectComments = true);
   JSONCPP_STRING getFormattedErrorMessages() const;
   std::vector<StructuredError> getStructuredErrors() const;
   bool pushError(const Value& value, const JSONCPP_STRING& message);
-  bool pushError(const Value& value, const JSONCPP_STRING& message,
-                 const Value& extra);
+  bool pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra);
   bool good() const;
 
 private:
-  OurReader(OurReader const&);      // no impl
-  void operator=(OurReader const&); // no impl
+  OurReader(OurReader const&);  // no impl
+  void operator=(OurReader const&);  // no impl
 
-  enum TokenType
-  {
+  enum TokenType {
     tokenEndOfStream = 0,
     tokenObjectBegin,
     tokenObjectEnd,
@@ -1034,16 +962,14 @@ private:
     tokenError
   };
 
-  class Token
-  {
+  class Token {
   public:
     TokenType type_;
     Location start_;
     Location end_;
   };
 
-  class ErrorInfo
-  {
+  class ErrorInfo {
   public:
     Token token_;
     JSONCPP_STRING message_;
@@ -1070,20 +996,24 @@ private:
   bool decodeString(Token& token, JSONCPP_STRING& decoded);
   bool decodeDouble(Token& token);
   bool decodeDouble(Token& token, Value& decoded);
-  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
+  bool decodeUnicodeCodePoint(Token& token,
+                              Location& current,
+                              Location end,
                               unsigned int& unicode);
-  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
-                                   Location end, unsigned int& unicode);
-  bool addError(const JSONCPP_STRING& message, Token& token,
-                Location extra = 0);
+  bool decodeUnicodeEscapeSequence(Token& token,
+                                   Location& current,
+                                   Location end,
+                                   unsigned int& unicode);
+  bool addError(const JSONCPP_STRING& message, Token& token, Location extra = 0);
   bool recoverFromError(TokenType skipUntilToken);
-  bool addErrorAndRecover(const JSONCPP_STRING& message, Token& token,
+  bool addErrorAndRecover(const JSONCPP_STRING& message,
+                          Token& token,
                           TokenType skipUntilToken);
   void skipUntilSpace();
   Value& currentValue();
   Char getNextChar();
-  void getLocationLineAndColumn(Location location, int& line,
-                                int& column) const;
+  void
+  getLocationLineAndColumn(Location location, int& line, int& column) const;
   JSONCPP_STRING getLocationLineAndColumn(Location location) const;
   void addComment(Location begin, Location end, CommentPlacement placement);
   void skipCommentTokens(Token& token);
@@ -1104,13 +1034,11 @@ private:
 
   OurFeatures const features_;
   bool collectComments_;
-}; // OurReader
+};  // OurReader
 
 // complete copy of Read impl, for OurReader
 
-bool OurReader::containsNewLine(OurReader::Location begin,
-                                OurReader::Location end)
-{
+bool OurReader::containsNewLine(OurReader::Location begin, OurReader::Location end) {
   for (; begin < end; ++begin)
     if (*begin == '\n' || *begin == '\r')
       return true;
@@ -1118,322 +1046,315 @@ bool OurReader::containsNewLine(OurReader::Location begin,
 }
 
 OurReader::OurReader(OurFeatures const& features)
-  : errors_()
-  , document_()
-  , begin_()
-  , end_()
-  , current_()
-  , lastValueEnd_()
-  , lastValue_()
-  , commentsBefore_()
-  , features_(features)
-  , collectComments_()
-{
+    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
+      lastValue_(), commentsBefore_(),
+      features_(features), collectComments_() {
 }
 
-bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
-                      bool collectComments)
-{
-  if (!this->features_.allowComments_) {
+bool OurReader::parse(const char* beginDoc,
+                   const char* endDoc,
+                   Value& root,
+                   bool collectComments) {
+  if (!features_.allowComments_) {
     collectComments = false;
   }
 
-  this->begin_ = beginDoc;
-  this->end_ = endDoc;
-  this->collectComments_ = collectComments;
-  this->current_ = this->begin_;
-  this->lastValueEnd_ = 0;
-  this->lastValue_ = 0;
-  this->commentsBefore_.clear();
-  this->errors_.clear();
-  while (!this->nodes_.empty())
-    this->nodes_.pop();
-  this->nodes_.push(&root);
-
-  bool successful = this->readValue();
+  begin_ = beginDoc;
+  end_ = endDoc;
+  collectComments_ = collectComments;
+  current_ = begin_;
+  lastValueEnd_ = 0;
+  lastValue_ = 0;
+  commentsBefore_.clear();
+  errors_.clear();
+  while (!nodes_.empty())
+    nodes_.pop();
+  nodes_.push(&root);
+
+  bool successful = readValue();
   Token token;
-  this->skipCommentTokens(token);
-  if (this->features_.failIfExtra_) {
-    if ((this->features_.strictRoot_ || token.type_ != tokenError) &&
-        token.type_ != tokenEndOfStream) {
-      this->addError("Extra non-whitespace after JSON value.", token);
+  skipCommentTokens(token);
+  if (features_.failIfExtra_) {
+    if ((features_.strictRoot_ || token.type_ != tokenError) && token.type_ != tokenEndOfStream) {
+      addError("Extra non-whitespace after JSON value.", token);
       return false;
     }
   }
-  if (this->collectComments_ && !this->commentsBefore_.empty())
-    root.setComment(this->commentsBefore_, commentAfter);
-  if (this->features_.strictRoot_) {
+  if (collectComments_ && !commentsBefore_.empty())
+    root.setComment(commentsBefore_, commentAfter);
+  if (features_.strictRoot_) {
     if (!root.isArray() && !root.isObject()) {
-      // Set error location to start of doc, ideally should be first token
-      // found in doc
+      // Set error location to start of doc, ideally should be first token found
+      // in doc
       token.type_ = tokenError;
       token.start_ = beginDoc;
       token.end_ = endDoc;
-      this->addError(
-        "A valid JSON document must be either an array or an object value.",
-        token);
+      addError(
+          "A valid JSON document must be either an array or an object value.",
+          token);
       return false;
     }
   }
   return successful;
 }
 
-bool OurReader::readValue()
-{
+bool OurReader::readValue() {
   //  To preserve the old behaviour we cast size_t to int.
-  if (static_cast<int>(this->nodes_.size()) > this->features_.stackLimit_)
-    throwRuntimeError("Exceeded stackLimit in readValue().");
+  if (static_cast<int>(nodes_.size()) > features_.stackLimit_) throwRuntimeError("Exceeded stackLimit in readValue().");
   Token token;
-  this->skipCommentTokens(token);
+  skipCommentTokens(token);
   bool successful = true;
 
-  if (this->collectComments_ && !this->commentsBefore_.empty()) {
-    this->currentValue().setComment(this->commentsBefore_, commentBefore);
-    this->commentsBefore_.clear();
+  if (collectComments_ && !commentsBefore_.empty()) {
+    currentValue().setComment(commentsBefore_, commentBefore);
+    commentsBefore_.clear();
   }
 
   switch (token.type_) {
-    case tokenObjectBegin:
-      successful = this->readObject(token);
-      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
-      break;
-    case tokenArrayBegin:
-      successful = this->readArray(token);
-      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
-      break;
-    case tokenNumber:
-      successful = this->decodeNumber(token);
-      break;
-    case tokenString:
-      successful = this->decodeString(token);
-      break;
-    case tokenTrue: {
-      Value v(true);
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenFalse: {
-      Value v(false);
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenNull: {
+  case tokenObjectBegin:
+    successful = readObject(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenArrayBegin:
+    successful = readArray(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenNumber:
+    successful = decodeNumber(token);
+    break;
+  case tokenString:
+    successful = decodeString(token);
+    break;
+  case tokenTrue:
+    {
+    Value v(true);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenFalse:
+    {
+    Value v(false);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenNull:
+    {
+    Value v;
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenNaN:
+    {
+    Value v(std::numeric_limits<double>::quiet_NaN());
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenPosInf:
+    {
+    Value v(std::numeric_limits<double>::infinity());
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenNegInf:
+    {
+    Value v(-std::numeric_limits<double>::infinity());
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    }
+    break;
+  case tokenArraySeparator:
+  case tokenObjectEnd:
+  case tokenArrayEnd:
+    if (features_.allowDroppedNullPlaceholders_) {
+      // "Un-read" the current token and mark the current value as a null
+      // token.
+      current_--;
       Value v;
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenNaN: {
-      Value v(std::numeric_limits<double>::quiet_NaN());
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenPosInf: {
-      Value v(std::numeric_limits<double>::infinity());
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenNegInf: {
-      Value v(-std::numeric_limits<double>::infinity());
-      this->currentValue().swapPayload(v);
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-    } break;
-    case tokenArraySeparator:
-    case tokenObjectEnd:
-    case tokenArrayEnd:
-      if (this->features_.allowDroppedNullPlaceholders_) {
-        // "Un-read" the current token and mark the current value as a null
-        // token.
-        this->current_--;
-        Value v;
-        this->currentValue().swapPayload(v);
-        this->currentValue().setOffsetStart(this->current_ - this->begin_ - 1);
-        this->currentValue().setOffsetLimit(this->current_ - this->begin_);
-        break;
-      } // else, fall through ...
-    default:
-      this->currentValue().setOffsetStart(token.start_ - this->begin_);
-      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
-      return this->addError("Syntax error: value, object or array expected.",
-                            token);
+      currentValue().swapPayload(v);
+      currentValue().setOffsetStart(current_ - begin_ - 1);
+      currentValue().setOffsetLimit(current_ - begin_);
+      break;
+    } // else, fall through ...
+  default:
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    return addError("Syntax error: value, object or array expected.", token);
   }
 
-  if (this->collectComments_) {
-    this->lastValueEnd_ = this->current_;
-    this->lastValue_ = &this->currentValue();
+  if (collectComments_) {
+    lastValueEnd_ = current_;
+    lastValue_ = &currentValue();
   }
 
   return successful;
 }
 
-void OurReader::skipCommentTokens(Token& token)
-{
-  if (this->features_.allowComments_) {
+void OurReader::skipCommentTokens(Token& token) {
+  if (features_.allowComments_) {
     do {
-      this->readToken(token);
+      readToken(token);
     } while (token.type_ == tokenComment);
   } else {
-    this->readToken(token);
+    readToken(token);
   }
 }
 
-bool OurReader::readToken(Token& token)
-{
-  this->skipSpaces();
-  token.start_ = this->current_;
-  Char c = this->getNextChar();
+bool OurReader::readToken(Token& token) {
+  skipSpaces();
+  token.start_ = current_;
+  Char c = getNextChar();
   bool ok = true;
   switch (c) {
-    case '{':
-      token.type_ = tokenObjectBegin;
-      break;
-    case '}':
-      token.type_ = tokenObjectEnd;
-      break;
-    case '[':
-      token.type_ = tokenArrayBegin;
-      break;
-    case ']':
-      token.type_ = tokenArrayEnd;
-      break;
-    case '"':
-      token.type_ = tokenString;
-      ok = this->readString();
-      break;
-    case '\'':
-      if (this->features_.allowSingleQuotes_) {
-        token.type_ = tokenString;
-        ok = this->readStringSingleQuote();
-        break;
-      } // else continue
-    case '/':
-      token.type_ = tokenComment;
-      ok = this->readComment();
-      break;
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
+  case '{':
+    token.type_ = tokenObjectBegin;
+    break;
+  case '}':
+    token.type_ = tokenObjectEnd;
+    break;
+  case '[':
+    token.type_ = tokenArrayBegin;
+    break;
+  case ']':
+    token.type_ = tokenArrayEnd;
+    break;
+  case '"':
+    token.type_ = tokenString;
+    ok = readString();
+    break;
+  case '\'':
+    if (features_.allowSingleQuotes_) {
+    token.type_ = tokenString;
+    ok = readStringSingleQuote();
+    break;
+    } // else continue
+  case '/':
+    token.type_ = tokenComment;
+    ok = readComment();
+    break;
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+    token.type_ = tokenNumber;
+    readNumber(false);
+    break;
+  case '-':
+    if (readNumber(true)) {
       token.type_ = tokenNumber;
-      this->readNumber(false);
-      break;
-    case '-':
-      if (this->readNumber(true)) {
-        token.type_ = tokenNumber;
-      } else {
-        token.type_ = tokenNegInf;
-        ok = this->features_.allowSpecialFloats_ && this->match("nfinity", 7);
-      }
-      break;
-    case 't':
-      token.type_ = tokenTrue;
-      ok = this->match("rue", 3);
-      break;
-    case 'f':
-      token.type_ = tokenFalse;
-      ok = this->match("alse", 4);
-      break;
-    case 'n':
-      token.type_ = tokenNull;
-      ok = this->match("ull", 3);
-      break;
-    case 'N':
-      if (this->features_.allowSpecialFloats_) {
-        token.type_ = tokenNaN;
-        ok = this->match("aN", 2);
-      } else {
-        ok = false;
-      }
-      break;
-    case 'I':
-      if (this->features_.allowSpecialFloats_) {
-        token.type_ = tokenPosInf;
-        ok = this->match("nfinity", 7);
-      } else {
-        ok = false;
-      }
-      break;
-    case ',':
-      token.type_ = tokenArraySeparator;
-      break;
-    case ':':
-      token.type_ = tokenMemberSeparator;
-      break;
-    case 0:
-      token.type_ = tokenEndOfStream;
-      break;
-    default:
+    } else {
+      token.type_ = tokenNegInf;
+      ok = features_.allowSpecialFloats_ && match("nfinity", 7);
+    }
+    break;
+  case 't':
+    token.type_ = tokenTrue;
+    ok = match("rue", 3);
+    break;
+  case 'f':
+    token.type_ = tokenFalse;
+    ok = match("alse", 4);
+    break;
+  case 'n':
+    token.type_ = tokenNull;
+    ok = match("ull", 3);
+    break;
+  case 'N':
+    if (features_.allowSpecialFloats_) {
+      token.type_ = tokenNaN;
+      ok = match("aN", 2);
+    } else {
       ok = false;
-      break;
+    }
+    break;
+  case 'I':
+    if (features_.allowSpecialFloats_) {
+      token.type_ = tokenPosInf;
+      ok = match("nfinity", 7);
+    } else {
+      ok = false;
+    }
+    break;
+  case ',':
+    token.type_ = tokenArraySeparator;
+    break;
+  case ':':
+    token.type_ = tokenMemberSeparator;
+    break;
+  case 0:
+    token.type_ = tokenEndOfStream;
+    break;
+  default:
+    ok = false;
+    break;
   }
   if (!ok)
     token.type_ = tokenError;
-  token.end_ = this->current_;
+  token.end_ = current_;
   return true;
 }
 
-void OurReader::skipSpaces()
-{
-  while (this->current_ != this->end_) {
-    Char c = *this->current_;
+void OurReader::skipSpaces() {
+  while (current_ != end_) {
+    Char c = *current_;
     if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
-      ++this->current_;
+      ++current_;
     else
       break;
   }
 }
 
-bool OurReader::match(Location pattern, int patternLength)
-{
-  if (this->end_ - this->current_ < patternLength)
+bool OurReader::match(Location pattern, int patternLength) {
+  if (end_ - current_ < patternLength)
     return false;
   int index = patternLength;
   while (index--)
-    if (this->current_[index] != pattern[index])
+    if (current_[index] != pattern[index])
       return false;
-  this->current_ += patternLength;
+  current_ += patternLength;
   return true;
 }
 
-bool OurReader::readComment()
-{
-  Location commentBegin = this->current_ - 1;
-  Char c = this->getNextChar();
+bool OurReader::readComment() {
+  Location commentBegin = current_ - 1;
+  Char c = getNextChar();
   bool successful = false;
   if (c == '*')
-    successful = this->readCStyleComment();
+    successful = readCStyleComment();
   else if (c == '/')
-    successful = this->readCppStyleComment();
+    successful = readCppStyleComment();
   if (!successful)
     return false;
 
-  if (this->collectComments_) {
+  if (collectComments_) {
     CommentPlacement placement = commentBefore;
-    if (this->lastValueEnd_ &&
-        !containsNewLine(this->lastValueEnd_, commentBegin)) {
-      if (c != '*' || !containsNewLine(commentBegin, this->current_))
+    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+      if (c != '*' || !containsNewLine(commentBegin, current_))
         placement = commentAfterOnSameLine;
     }
 
-    this->addComment(commentBegin, this->current_, placement);
+    addComment(commentBegin, current_, placement);
   }
   return true;
 }
 
-JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin,
-                                       OurReader::Location end)
-{
+JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin, OurReader::Location end) {
   JSONCPP_STRING normalized;
   normalized.reserve(static_cast<size_t>(end - begin));
   OurReader::Location current = begin;
@@ -1441,8 +1362,8 @@ JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin,
     char c = *current++;
     if (c == '\r') {
       if (current != end && *current == '\n')
-        // convert dos EOL
-        ++current;
+         // convert dos EOL
+         ++current;
       // convert Mac EOL
       normalized += '\n';
     } else {
@@ -1452,39 +1373,36 @@ JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin,
   return normalized;
 }
 
-void OurReader::addComment(Location begin, Location end,
-                           CommentPlacement placement)
-{
-  assert(this->collectComments_);
+void
+OurReader::addComment(Location begin, Location end, CommentPlacement placement) {
+  assert(collectComments_);
   const JSONCPP_STRING& normalized = normalizeEOL(begin, end);
   if (placement == commentAfterOnSameLine) {
-    assert(this->lastValue_ != 0);
-    this->lastValue_->setComment(normalized, placement);
+    assert(lastValue_ != 0);
+    lastValue_->setComment(normalized, placement);
   } else {
-    this->commentsBefore_ += normalized;
+    commentsBefore_ += normalized;
   }
 }
 
-bool OurReader::readCStyleComment()
-{
-  while ((this->current_ + 1) < this->end_) {
-    Char c = this->getNextChar();
-    if (c == '*' && *this->current_ == '/')
+bool OurReader::readCStyleComment() {
+  while ((current_ + 1) < end_) {
+    Char c = getNextChar();
+    if (c == '*' && *current_ == '/')
       break;
   }
-  return this->getNextChar() == '/';
+  return getNextChar() == '/';
 }
 
-bool OurReader::readCppStyleComment()
-{
-  while (this->current_ != this->end_) {
-    Char c = this->getNextChar();
+bool OurReader::readCppStyleComment() {
+  while (current_ != end_) {
+    Char c = getNextChar();
     if (c == '\n')
       break;
     if (c == '\r') {
       // Consume DOS EOL. It will be normalized in addComment.
-      if (this->current_ != this->end_ && *this->current_ == '\n')
-        this->getNextChar();
+      if (current_ != end_ && *current_ == '\n')
+        getNextChar();
       // Break on Moc OS 9 EOL.
       break;
     }
@@ -1492,156 +1410,150 @@ bool OurReader::readCppStyleComment()
   return true;
 }
 
-bool OurReader::readNumber(bool checkInf)
-{
-  const char* p = this->current_;
-  if (checkInf && p != this->end_ && *p == 'I') {
-    this->current_ = ++p;
+bool OurReader::readNumber(bool checkInf) {
+  const char *p = current_;
+  if (checkInf && p != end_ && *p == 'I') {
+    current_ = ++p;
     return false;
   }
   char c = '0'; // stopgap for already consumed character
   // integral part
   while (c >= '0' && c <= '9')
-    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+    c = (current_ = p) < end_ ? *p++ : '\0';
   // fractional part
   if (c == '.') {
-    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+    c = (current_ = p) < end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+      c = (current_ = p) < end_ ? *p++ : '\0';
   }
   // exponential part
   if (c == 'e' || c == 'E') {
-    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+    c = (current_ = p) < end_ ? *p++ : '\0';
     if (c == '+' || c == '-')
-      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+      c = (current_ = p) < end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
+      c = (current_ = p) < end_ ? *p++ : '\0';
   }
   return true;
 }
-bool OurReader::readString()
-{
+bool OurReader::readString() {
   Char c = 0;
-  while (this->current_ != this->end_) {
-    c = this->getNextChar();
+  while (current_ != end_) {
+    c = getNextChar();
     if (c == '\\')
-      this->getNextChar();
+      getNextChar();
     else if (c == '"')
       break;
   }
   return c == '"';
 }
 
-bool OurReader::readStringSingleQuote()
-{
+
+bool OurReader::readStringSingleQuote() {
   Char c = 0;
-  while (this->current_ != this->end_) {
-    c = this->getNextChar();
+  while (current_ != end_) {
+    c = getNextChar();
     if (c == '\\')
-      this->getNextChar();
+      getNextChar();
     else if (c == '\'')
       break;
   }
   return c == '\'';
 }
 
-bool OurReader::readObject(Token& tokenStart)
-{
+bool OurReader::readObject(Token& tokenStart) {
   Token tokenName;
   JSONCPP_STRING name;
   Value init(objectValue);
-  this->currentValue().swapPayload(init);
-  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
-  while (this->readToken(tokenName)) {
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(tokenStart.start_ - begin_);
+  while (readToken(tokenName)) {
     bool initialTokenOk = true;
     while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = this->readToken(tokenName);
+      initialTokenOk = readToken(tokenName);
     if (!initialTokenOk)
       break;
     if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
       return true;
     name.clear();
     if (tokenName.type_ == tokenString) {
-      if (!this->decodeString(tokenName, name))
-        return this->recoverFromError(tokenObjectEnd);
-    } else if (tokenName.type_ == tokenNumber &&
-               this->features_.allowNumericKeys_) {
+      if (!decodeString(tokenName, name))
+        return recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
       Value numberName;
-      if (!this->decodeNumber(tokenName, numberName))
-        return this->recoverFromError(tokenObjectEnd);
+      if (!decodeNumber(tokenName, numberName))
+        return recoverFromError(tokenObjectEnd);
       name = numberName.asString();
     } else {
       break;
     }
 
     Token colon;
-    if (!this->readToken(colon) || colon.type_ != tokenMemberSeparator) {
-      return this->addErrorAndRecover("Missing ':' after object member name",
-                                      colon, tokenObjectEnd);
+    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return addErrorAndRecover(
+          "Missing ':' after object member name", colon, tokenObjectEnd);
     }
-    if (name.length() >= (1U << 30))
-      throwRuntimeError("keylength >= 2^30");
-    if (this->features_.rejectDupKeys_ &&
-        this->currentValue().isMember(name)) {
+    if (name.length() >= (1U<<30)) throwRuntimeError("keylength >= 2^30");
+    if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
       JSONCPP_STRING msg = "Duplicate key: '" + name + "'";
-      return this->addErrorAndRecover(msg, tokenName, tokenObjectEnd);
+      return addErrorAndRecover(
+          msg, tokenName, tokenObjectEnd);
     }
-    Value& value = this->currentValue()[name];
-    this->nodes_.push(&value);
-    bool ok = this->readValue();
-    this->nodes_.pop();
+    Value& value = currentValue()[name];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
     if (!ok) // error already set
-      return this->recoverFromError(tokenObjectEnd);
+      return recoverFromError(tokenObjectEnd);
 
     Token comma;
-    if (!this->readToken(comma) ||
+    if (!readToken(comma) ||
         (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
          comma.type_ != tokenComment)) {
-      return this->addErrorAndRecover(
-        "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
+      return addErrorAndRecover(
+          "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
     }
     bool finalizeTokenOk = true;
     while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = this->readToken(comma);
+      finalizeTokenOk = readToken(comma);
     if (comma.type_ == tokenObjectEnd)
       return true;
   }
-  return this->addErrorAndRecover("Missing '}' or object member name",
-                                  tokenName, tokenObjectEnd);
+  return addErrorAndRecover(
+      "Missing '}' or object member name", tokenName, tokenObjectEnd);
 }
 
-bool OurReader::readArray(Token& tokenStart)
-{
+bool OurReader::readArray(Token& tokenStart) {
   Value init(arrayValue);
-  this->currentValue().swapPayload(init);
-  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
-  this->skipSpaces();
-  if (this->current_ != this->end_ && *this->current_ == ']') // empty array
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(tokenStart.start_ - begin_);
+  skipSpaces();
+  if (current_ != end_ && *current_ == ']') // empty array
   {
     Token endArray;
-    this->readToken(endArray);
+    readToken(endArray);
     return true;
   }
   int index = 0;
   for (;;) {
-    Value& value = this->currentValue()[index++];
-    this->nodes_.push(&value);
-    bool ok = this->readValue();
-    this->nodes_.pop();
+    Value& value = currentValue()[index++];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
     if (!ok) // error already set
-      return this->recoverFromError(tokenArrayEnd);
+      return recoverFromError(tokenArrayEnd);
 
     Token token;
     // Accept Comment after last item in the array.
-    ok = this->readToken(token);
+    ok = readToken(token);
     while (token.type_ == tokenComment && ok) {
-      ok = this->readToken(token);
+      ok = readToken(token);
     }
     bool badTokenType =
-      (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+        (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
     if (!ok || badTokenType) {
-      return this->addErrorAndRecover(
-        "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
+      return addErrorAndRecover(
+          "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
     }
     if (token.type_ == tokenArrayEnd)
       break;
@@ -1649,19 +1561,17 @@ bool OurReader::readArray(Token& tokenStart)
   return true;
 }
 
-bool OurReader::decodeNumber(Token& token)
-{
+bool OurReader::decodeNumber(Token& token) {
   Value decoded;
-  if (!this->decodeNumber(token, decoded))
+  if (!decodeNumber(token, decoded))
     return false;
-  this->currentValue().swapPayload(decoded);
-  this->currentValue().setOffsetStart(token.start_ - this->begin_);
-  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-bool OurReader::decodeNumber(Token& token, Value& decoded)
-{
+bool OurReader::decodeNumber(Token& token, Value& decoded) {
   // Attempts to parse the number as an integer. If the number is
   // larger than the maximum supported value of an integer then
   // we decode the number as a double.
@@ -1669,17 +1579,16 @@ bool OurReader::decodeNumber(Token& token, Value& decoded)
   bool isNegative = *current == '-';
   if (isNegative)
     ++current;
-  // TODO: Help the compiler do the div and mod at compile time or get rid of
-  // them.
-  Value::LargestUInt maxIntegerValue = isNegative
-    ? Value::LargestUInt(Value::minLargestInt)
-    : Value::maxLargestUInt;
+  // TODO: Help the compiler do the div and mod at compile time or get rid of them.
+  Value::LargestUInt maxIntegerValue =
+      isNegative ? Value::LargestUInt(Value::minLargestInt)
+                 : Value::maxLargestUInt;
   Value::LargestUInt threshold = maxIntegerValue / 10;
   Value::LargestUInt value = 0;
   while (current < token.end_) {
     Char c = *current++;
     if (c < '0' || c > '9')
-      return this->decodeDouble(token, decoded);
+      return decodeDouble(token, decoded);
     Value::UInt digit(static_cast<Value::UInt>(c - '0'));
     if (value >= threshold) {
       // We've hit or exceeded the max value divided by 10 (rounded down). If
@@ -1688,7 +1597,7 @@ bool OurReader::decodeNumber(Token& token, Value& decoded)
       // Otherwise treat this number as a double to avoid overflow.
       if (value > threshold || current != token.end_ ||
           digit > maxIntegerValue % 10) {
-        return this->decodeDouble(token, decoded);
+        return decodeDouble(token, decoded);
       }
     }
     value = value * 10 + digit;
@@ -1702,19 +1611,17 @@ bool OurReader::decodeNumber(Token& token, Value& decoded)
   return true;
 }
 
-bool OurReader::decodeDouble(Token& token)
-{
+bool OurReader::decodeDouble(Token& token) {
   Value decoded;
-  if (!this->decodeDouble(token, decoded))
+  if (!decodeDouble(token, decoded))
     return false;
-  this->currentValue().swapPayload(decoded);
-  this->currentValue().setOffsetStart(token.start_ - this->begin_);
-  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-bool OurReader::decodeDouble(Token& token, Value& decoded)
-{
+bool OurReader::decodeDouble(Token& token, Value& decoded) {
   double value = 0;
   const int bufferSize = 32;
   int count;
@@ -1722,7 +1629,7 @@ bool OurReader::decodeDouble(Token& token, Value& decoded)
 
   // Sanity check to avoid buffer overflow exploits.
   if (length < 0) {
-    return this->addError("Unable to parse token length", token);
+    return addError("Unable to parse token length", token);
   }
   size_t const ulength = static_cast<size_t>(length);
 
@@ -1745,27 +1652,25 @@ bool OurReader::decodeDouble(Token& token, Value& decoded)
   }
 
   if (count != 1)
-    return this->addError("'" + JSONCPP_STRING(token.start_, token.end_) +
-                            "' is not a number.",
-                          token);
+    return addError("'" + JSONCPP_STRING(token.start_, token.end_) +
+                        "' is not a number.",
+                    token);
   decoded = value;
   return true;
 }
 
-bool OurReader::decodeString(Token& token)
-{
+bool OurReader::decodeString(Token& token) {
   JSONCPP_STRING decoded_string;
-  if (!this->decodeString(token, decoded_string))
+  if (!decodeString(token, decoded_string))
     return false;
   Value decoded(decoded_string);
-  this->currentValue().swapPayload(decoded);
-  this->currentValue().setOffsetStart(token.start_ - this->begin_);
-  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded)
-{
+bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded) {
   decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
   Location current = token.start_ + 1; // skip '"'
   Location end = token.end_ - 1;       // do not include '"'
@@ -1775,43 +1680,41 @@ bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded)
       break;
     else if (c == '\\') {
       if (current == end)
-        return this->addError("Empty escape sequence in string", token,
-                              current);
+        return addError("Empty escape sequence in string", token, current);
       Char escape = *current++;
       switch (escape) {
-        case '"':
-          decoded += '"';
-          break;
-        case '/':
-          decoded += '/';
-          break;
-        case '\\':
-          decoded += '\\';
-          break;
-        case 'b':
-          decoded += '\b';
-          break;
-        case 'f':
-          decoded += '\f';
-          break;
-        case 'n':
-          decoded += '\n';
-          break;
-        case 'r':
-          decoded += '\r';
-          break;
-        case 't':
-          decoded += '\t';
-          break;
-        case 'u': {
-          unsigned int unicode;
-          if (!this->decodeUnicodeCodePoint(token, current, end, unicode))
-            return false;
-          decoded += codePointToUTF8(unicode);
-        } break;
-        default:
-          return this->addError("Bad escape sequence in string", token,
-                                current);
+      case '"':
+        decoded += '"';
+        break;
+      case '/':
+        decoded += '/';
+        break;
+      case '\\':
+        decoded += '\\';
+        break;
+      case 'b':
+        decoded += '\b';
+        break;
+      case 'f':
+        decoded += '\f';
+        break;
+      case 'n':
+        decoded += '\n';
+        break;
+      case 'r':
+        decoded += '\r';
+        break;
+      case 't':
+        decoded += '\t';
+        break;
+      case 'u': {
+        unsigned int unicode;
+        if (!decodeUnicodeCodePoint(token, current, end, unicode))
+          return false;
+        decoded += codePointToUTF8(unicode);
+      } break;
+      default:
+        return addError("Bad escape sequence in string", token, current);
       }
     } else {
       decoded += c;
@@ -1820,44 +1723,45 @@ bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded)
   return true;
 }
 
-bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
-                                       Location end, unsigned int& unicode)
-{
+bool OurReader::decodeUnicodeCodePoint(Token& token,
+                                    Location& current,
+                                    Location end,
+                                    unsigned int& unicode) {
 
   unicode = 0; // Convince scanbuild this is always initialized before use.
-  if (!this->decodeUnicodeEscapeSequence(token, current, end, unicode))
+  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
     return false;
   if (unicode >= 0xD800 && unicode <= 0xDBFF) {
     // surrogate pairs
     if (end - current < 6)
-      return this->addError(
-        "additional six characters expected to parse unicode surrogate pair.",
-        token, current);
+      return addError(
+          "additional six characters expected to parse unicode surrogate pair.",
+          token,
+          current);
     unsigned int surrogatePair;
     if (*(current++) == '\\' && *(current++) == 'u') {
-      if (this->decodeUnicodeEscapeSequence(token, current, end,
-                                            surrogatePair)) {
-        unicode =
-          0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
+        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
       } else
         return false;
     } else
-      return this->addError(
-        "expecting another \\u token to begin the second half of "
-        "a unicode surrogate pair",
-        token, current);
+      return addError("expecting another \\u token to begin the second half of "
+                      "a unicode surrogate pair",
+                      token,
+                      current);
   }
   return true;
 }
 
-bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
-                                            Location end,
-                                            unsigned int& ret_unicode)
-{
+bool OurReader::decodeUnicodeEscapeSequence(Token& token,
+                                         Location& current,
+                                         Location end,
+                                         unsigned int& ret_unicode) {
   if (end - current < 4)
-    return this->addError(
-      "Bad unicode escape sequence in string: four digits expected.", token,
-      current);
+    return addError(
+        "Bad unicode escape sequence in string: four digits expected.",
+        token,
+        current);
   int unicode = 0;
   for (int index = 0; index < 4; ++index) {
     Char c = *current++;
@@ -1869,65 +1773,60 @@ bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
     else if (c >= 'A' && c <= 'F')
       unicode += c - 'A' + 10;
     else
-      return this->addError(
-        "Bad unicode escape sequence in string: hexadecimal digit expected.",
-        token, current);
+      return addError(
+          "Bad unicode escape sequence in string: hexadecimal digit expected.",
+          token,
+          current);
   }
   ret_unicode = static_cast<unsigned int>(unicode);
   return true;
 }
 
-bool OurReader::addError(const JSONCPP_STRING& message, Token& token,
-                         Location extra)
-{
+bool
+OurReader::addError(const JSONCPP_STRING& message, Token& token, Location extra) {
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = extra;
-  this->errors_.push_back(info);
+  errors_.push_back(info);
   return false;
 }
 
-bool OurReader::recoverFromError(TokenType skipUntilToken)
-{
-  size_t errorCount = this->errors_.size();
+bool OurReader::recoverFromError(TokenType skipUntilToken) {
+  size_t errorCount = errors_.size();
   Token skip;
   for (;;) {
-    if (!this->readToken(skip))
-      this->errors_.resize(errorCount); // discard errors caused by recovery
+    if (!readToken(skip))
+      errors_.resize(errorCount); // discard errors caused by recovery
     if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
       break;
   }
-  this->errors_.resize(errorCount);
+  errors_.resize(errorCount);
   return false;
 }
 
-bool OurReader::addErrorAndRecover(const JSONCPP_STRING& message, Token& token,
-                                   TokenType skipUntilToken)
-{
-  this->addError(message, token);
-  return this->recoverFromError(skipUntilToken);
+bool OurReader::addErrorAndRecover(const JSONCPP_STRING& message,
+                                Token& token,
+                                TokenType skipUntilToken) {
+  addError(message, token);
+  return recoverFromError(skipUntilToken);
 }
 
-Value& OurReader::currentValue()
-{
-  return *(this->nodes_.top());
-}
+Value& OurReader::currentValue() { return *(nodes_.top()); }
 
-OurReader::Char OurReader::getNextChar()
-{
-  if (this->current_ == this->end_)
+OurReader::Char OurReader::getNextChar() {
+  if (current_ == end_)
     return 0;
-  return *this->current_++;
+  return *current_++;
 }
 
-void OurReader::getLocationLineAndColumn(Location location, int& line,
-                                         int& column) const
-{
-  Location current = this->begin_;
+void OurReader::getLocationLineAndColumn(Location location,
+                                      int& line,
+                                      int& column) const {
+  Location current = begin_;
   Location lastLineStart = current;
   line = 0;
-  while (current < location && current != this->end_) {
+  while (current < location && current != end_) {
     Char c = *current++;
     if (c == '\r') {
       if (*current == '\n')
@@ -1944,105 +1843,101 @@ void OurReader::getLocationLineAndColumn(Location location, int& line,
   ++line;
 }
 
-JSONCPP_STRING OurReader::getLocationLineAndColumn(Location location) const
-{
+JSONCPP_STRING OurReader::getLocationLineAndColumn(Location location) const {
   int line, column;
-  this->getLocationLineAndColumn(location, line, column);
+  getLocationLineAndColumn(location, line, column);
   char buffer[18 + 16 + 16 + 1];
   snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
   return buffer;
 }
 
-JSONCPP_STRING OurReader::getFormattedErrorMessages() const
-{
+JSONCPP_STRING OurReader::getFormattedErrorMessages() const {
   JSONCPP_STRING formattedMessage;
-  for (Errors::const_iterator itError = this->errors_.begin();
-       itError != this->errors_.end(); ++itError) {
+  for (Errors::const_iterator itError = errors_.begin();
+       itError != errors_.end();
+       ++itError) {
     const ErrorInfo& error = *itError;
     formattedMessage +=
-      "* " + this->getLocationLineAndColumn(error.token_.start_) + "\n";
+        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
     formattedMessage += "  " + error.message_ + "\n";
     if (error.extra_)
-      formattedMessage += "See " +
-        this->getLocationLineAndColumn(error.extra_) + " for detail.\n";
+      formattedMessage +=
+          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
   }
   return formattedMessage;
 }
 
-std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const
-{
+std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
   std::vector<OurReader::StructuredError> allErrors;
-  for (Errors::const_iterator itError = this->errors_.begin();
-       itError != this->errors_.end(); ++itError) {
+  for (Errors::const_iterator itError = errors_.begin();
+       itError != errors_.end();
+       ++itError) {
     const ErrorInfo& error = *itError;
     OurReader::StructuredError structured;
-    structured.offset_start = error.token_.start_ - this->begin_;
-    structured.offset_limit = error.token_.end_ - this->begin_;
+    structured.offset_start = error.token_.start_ - begin_;
+    structured.offset_limit = error.token_.end_ - begin_;
     structured.message = error.message_;
     allErrors.push_back(structured);
   }
   return allErrors;
 }
 
-bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message)
-{
-  ptrdiff_t length = this->end_ - this->begin_;
-  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
+bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message) {
+  ptrdiff_t length = end_ - begin_;
+  if(value.getOffsetStart() > length
+    || value.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = this->begin_ + value.getOffsetStart();
-  token.end_ = this->end_ + value.getOffsetLimit();
+  token.start_ = begin_ + value.getOffsetStart();
+  token.end_ = end_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = 0;
-  this->errors_.push_back(info);
+  errors_.push_back(info);
   return true;
 }
 
-bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message,
-                          const Value& extra)
-{
-  ptrdiff_t length = this->end_ - this->begin_;
-  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
-      extra.getOffsetLimit() > length)
+bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra) {
+  ptrdiff_t length = end_ - begin_;
+  if(value.getOffsetStart() > length
+    || value.getOffsetLimit() > length
+    || extra.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = this->begin_ + value.getOffsetStart();
-  token.end_ = this->begin_ + value.getOffsetLimit();
+  token.start_ = begin_ + value.getOffsetStart();
+  token.end_ = begin_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
-  info.extra_ = this->begin_ + extra.getOffsetStart();
-  this->errors_.push_back(info);
+  info.extra_ = begin_ + extra.getOffsetStart();
+  errors_.push_back(info);
   return true;
 }
 
-bool OurReader::good() const
-{
-  return !this->errors_.size();
+bool OurReader::good() const {
+  return !errors_.size();
 }
 
-class OurCharReader : public CharReader
-{
+
+class OurCharReader : public CharReader {
   bool const collectComments_;
   OurReader reader_;
-
 public:
-  OurCharReader(bool collectComments, OurFeatures const& features)
-    : collectComments_(collectComments)
-    , reader_(features)
-  {
-  }
-  bool parse(char const* beginDoc, char const* endDoc, Value* root,
-             JSONCPP_STRING* errs) JSONCPP_OVERRIDE
-  {
-    bool ok =
-      this->reader_.parse(beginDoc, endDoc, *root, this->collectComments_);
+  OurCharReader(
+    bool collectComments,
+    OurFeatures const& features)
+  : collectComments_(collectComments)
+  , reader_(features)
+  {}
+  bool parse(
+      char const* beginDoc, char const* endDoc,
+      Value* root, JSONCPP_STRING* errs) JSONCPP_OVERRIDE {
+    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
     if (errs) {
-      *errs = this->reader_.getFormattedErrorMessages();
+      *errs = reader_.getFormattedErrorMessages();
     }
     return ok;
   }
@@ -2050,26 +1945,23 @@ public:
 
 CharReaderBuilder::CharReaderBuilder()
 {
-  setDefaults(&this->settings_);
+  setDefaults(&settings_);
 }
 CharReaderBuilder::~CharReaderBuilder()
-{
-}
+{}
 CharReader* CharReaderBuilder::newCharReader() const
 {
-  bool collectComments = this->settings_["collectComments"].asBool();
+  bool collectComments = settings_["collectComments"].asBool();
   OurFeatures features = OurFeatures::all();
-  features.allowComments_ = this->settings_["allowComments"].asBool();
-  features.strictRoot_ = this->settings_["strictRoot"].asBool();
-  features.allowDroppedNullPlaceholders_ =
-    this->settings_["allowDroppedNullPlaceholders"].asBool();
-  features.allowNumericKeys_ = this->settings_["allowNumericKeys"].asBool();
-  features.allowSingleQuotes_ = this->settings_["allowSingleQuotes"].asBool();
-  features.stackLimit_ = this->settings_["stackLimit"].asInt();
-  features.failIfExtra_ = this->settings_["failIfExtra"].asBool();
-  features.rejectDupKeys_ = this->settings_["rejectDupKeys"].asBool();
-  features.allowSpecialFloats_ =
-    this->settings_["allowSpecialFloats"].asBool();
+  features.allowComments_ = settings_["allowComments"].asBool();
+  features.strictRoot_ = settings_["strictRoot"].asBool();
+  features.allowDroppedNullPlaceholders_ = settings_["allowDroppedNullPlaceholders"].asBool();
+  features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
+  features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
+  features.stackLimit_ = settings_["stackLimit"].asInt();
+  features.failIfExtra_ = settings_["failIfExtra"].asBool();
+  features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
+  features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
   return new OurCharReader(collectComments, features);
 }
 static void getValidReaderKeys(std::set<JSONCPP_STRING>* valid_keys)
@@ -2089,29 +1981,28 @@ static void getValidReaderKeys(std::set<JSONCPP_STRING>* valid_keys)
 bool CharReaderBuilder::validate(Json::Value* invalid) const
 {
   Json::Value my_invalid;
-  if (!invalid)
-    invalid = &my_invalid; // so we do not need to test for NULL
+  if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
   Json::Value& inv = *invalid;
   std::set<JSONCPP_STRING> valid_keys;
   getValidReaderKeys(&valid_keys);
-  Value::Members keys = this->settings_.getMemberNames();
+  Value::Members keys = settings_.getMemberNames();
   size_t n = keys.size();
   for (size_t i = 0; i < n; ++i) {
     JSONCPP_STRING const& key = keys[i];
     if (valid_keys.find(key) == valid_keys.end()) {
-      inv[key] = this->settings_[key];
+      inv[key] = settings_[key];
     }
   }
   return 0u == inv.size();
 }
 Value& CharReaderBuilder::operator[](JSONCPP_STRING key)
 {
-  return this->settings_[key];
+  return settings_[key];
 }
 // static
 void CharReaderBuilder::strictMode(Json::Value* settings)
 {
-  //! [CharReaderBuilderStrictMode]
+//! [CharReaderBuilderStrictMode]
   (*settings)["allowComments"] = false;
   (*settings)["strictRoot"] = true;
   (*settings)["allowDroppedNullPlaceholders"] = false;
@@ -2121,12 +2012,12 @@ void CharReaderBuilder::strictMode(Json::Value* settings)
   (*settings)["failIfExtra"] = true;
   (*settings)["rejectDupKeys"] = true;
   (*settings)["allowSpecialFloats"] = false;
-  //! [CharReaderBuilderStrictMode]
+//! [CharReaderBuilderStrictMode]
 }
 // static
 void CharReaderBuilder::setDefaults(Json::Value* settings)
 {
-  //! [CharReaderBuilderDefaults]
+//! [CharReaderBuilderDefaults]
   (*settings)["collectComments"] = true;
   (*settings)["allowComments"] = true;
   (*settings)["strictRoot"] = false;
@@ -2137,14 +2028,15 @@ void CharReaderBuilder::setDefaults(Json::Value* settings)
   (*settings)["failIfExtra"] = false;
   (*settings)["rejectDupKeys"] = false;
   (*settings)["allowSpecialFloats"] = false;
-  //! [CharReaderBuilderDefaults]
+//! [CharReaderBuilderDefaults]
 }
 
 //////////////////////////////////
 // global functions
 
-bool parseFromStream(CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
-                     Value* root, JSONCPP_STRING* errs)
+bool parseFromStream(
+    CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
+    Value* root, JSONCPP_STRING* errs)
 {
   JSONCPP_OSTRINGSTREAM ssin;
   ssin << sin.rdbuf();
@@ -2156,13 +2048,14 @@ bool parseFromStream(CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
   return reader->parse(begin, end, root, errs);
 }
 
-JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root)
-{
+JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root) {
   CharReaderBuilder b;
   JSONCPP_STRING errs;
   bool ok = parseFromStream(b, sin, &root, &errs);
   if (!ok) {
-    fprintf(stderr, "Error from reader: %s", errs.c_str());
+    fprintf(stderr,
+            "Error from reader: %s",
+            errs.c_str());
 
     throwRuntimeError(errs);
   }
diff --git a/Utilities/cmjsoncpp/src/lib_json/json_value.cpp b/Utilities/cmjsoncpp/src/lib_json/json_value.cpp
index eadb1c3..f271e57 100644
--- a/Utilities/cmjsoncpp/src/lib_json/json_value.cpp
+++ b/Utilities/cmjsoncpp/src/lib_json/json_value.cpp
@@ -1,25 +1,23 @@
 // Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
-// See file LICENSE for detail or copy at
-// http://jsoncpp.sourceforge.net/LICENSE
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-#  include <json/assertions.h>
-#  include <json/value.h>
-#  include <json/writer.h>
+#include <json/assertions.h>
+#include <json/value.h>
+#include <json/writer.h>
 #endif // if !defined(JSON_IS_AMALGAMATION)
+#include <math.h>
 #include <sstream>
 #include <utility>
-
-#include <assert.h>
-#include <math.h>
 #include <string.h>
+#include <assert.h>
 #ifdef JSON_USE_CPPTL
-#  include <cpptl/conststring.h>
+#include <cpptl/conststring.h>
 #endif
+#include <cstddef> // size_t
 #include <algorithm> // min()
-#include <cstddef>   // size_t
 
 #define JSON_ASSERT_UNREACHABLE assert(false)
 
@@ -29,24 +27,24 @@ namespace Json {
 // kNull must be word-aligned to avoid crashing on ARM.  We use an alignment of
 // 8 (instead of 4) as a bit of future-proofing.
 #if defined(__ARMEL__)
-#  define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
+#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
 #else
-#  define ALIGNAS(byte_alignment)
+#define ALIGNAS(byte_alignment)
 #endif
-// static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };
-// const unsigned char& kNullRef = kNull[0];
-// const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);
-// const Value& Value::nullRef = null;
+//static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };
+//const unsigned char& kNullRef = kNull[0];
+//const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);
+//const Value& Value::nullRef = null;
 
 // static
 Value const& Value::nullSingleton()
 {
-  static Value const nullStatic;
-  return nullStatic;
+ static Value const nullStatic;
+ return nullStatic;
 }
 
-// for backwards compatibility, we'll leave these global references around, but
-// DO NOT use them in JSONCPP library code any more!
+// for backwards compatibility, we'll leave these global references around, but DO NOT
+// use them in JSONCPP library code any more!
 Value const& Value::null = Value::nullSingleton();
 Value const& Value::nullRef = Value::nullSingleton();
 
@@ -68,29 +66,23 @@ const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
 
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 template <typename T, typename U>
-static inline bool InRange(double d, T min, U max)
-{
+static inline bool InRange(double d, T min, U max) {
   // The casts can lose precision, but we are looking only for
   // an approximate range. Might fail on edge cases though. ~cdunn
-  // return d >= static_cast<double>(min) && d <= static_cast<double>(max);
+  //return d >= static_cast<double>(min) && d <= static_cast<double>(max);
   return d >= min && d <= max;
 }
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double integerToDouble(Json::UInt64 value)
-{
-  return static_cast<double>(Int64(value / 2)) * 2.0 +
-    static_cast<double>(Int64(value & 1));
+static inline double integerToDouble(Json::UInt64 value) {
+  return static_cast<double>(Int64(value / 2)) * 2.0 + static_cast<double>(Int64(value & 1));
 }
 
-template <typename T>
-static inline double integerToDouble(T value)
-{
+template <typename T> static inline double integerToDouble(T value) {
   return static_cast<double>(value);
 }
 
 template <typename T, typename U>
-static inline bool InRange(double d, T min, U max)
-{
+static inline bool InRange(double d, T min, U max) {
   return d >= integerToDouble(min) && d <= integerToDouble(max);
 }
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
@@ -102,7 +94,8 @@ static inline bool InRange(double d, T min, U max)
  *               computed using strlen(value).
  * @return Pointer on the duplicate instance of string.
  */
-static inline char* duplicateStringValue(const char* value, size_t length)
+static inline char* duplicateStringValue(const char* value,
+                                         size_t length)
 {
   // Avoid an integer overflow in the call to malloc below by limiting length
   // to a sane value.
@@ -111,8 +104,9 @@ static inline char* duplicateStringValue(const char* value, size_t length)
 
   char* newString = static_cast<char*>(malloc(length + 1));
   if (newString == NULL) {
-    throwRuntimeError("in Json::Value::duplicateStringValue(): "
-                      "Failed to allocate string value buffer");
+    throwRuntimeError(
+        "in Json::Value::duplicateStringValue(): "
+        "Failed to allocate string value buffer");
   }
   memcpy(newString, value, length);
   newString[length] = 0;
@@ -121,30 +115,30 @@ static inline char* duplicateStringValue(const char* value, size_t length)
 
 /* Record the length as a prefix.
  */
-static inline char* duplicateAndPrefixStringValue(const char* value,
-                                                  unsigned int length)
+static inline char* duplicateAndPrefixStringValue(
+    const char* value,
+    unsigned int length)
 {
   // Avoid an integer overflow in the call to malloc below by limiting length
   // to a sane value.
-  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
-                          sizeof(unsigned) - 1U,
+  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) - sizeof(unsigned) - 1U,
                       "in Json::Value::duplicateAndPrefixStringValue(): "
                       "length too big for prefixing");
-  unsigned actualLength =
-    length + static_cast<unsigned>(sizeof(unsigned)) + 1U;
+  unsigned actualLength = length + static_cast<unsigned>(sizeof(unsigned)) + 1U;
   char* newString = static_cast<char*>(malloc(actualLength));
   if (newString == 0) {
-    throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
-                      "Failed to allocate string value buffer");
+    throwRuntimeError(
+        "in Json::Value::duplicateAndPrefixStringValue(): "
+        "Failed to allocate string value buffer");
   }
   *reinterpret_cast<unsigned*>(newString) = length;
   memcpy(newString + sizeof(unsigned), value, length);
-  newString[actualLength - 1U] =
-    0; // to avoid buffer over-run accidents by users later
+  newString[actualLength - 1U] = 0; // to avoid buffer over-run accidents by users later
   return newString;
 }
-inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
-                                        unsigned* length, char const** value)
+inline static void decodePrefixedString(
+    bool isPrefixed, char const* prefixed,
+    unsigned* length, char const** value)
 {
   if (!isPrefixed) {
     *length = static_cast<unsigned>(strlen(prefixed));
@@ -154,12 +148,10 @@ inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
     *value = prefixed + sizeof(unsigned);
   }
 }
-/** Free the string duplicated by
- * duplicateStringValue()/duplicateAndPrefixStringValue().
+/** Free the string duplicated by duplicateStringValue()/duplicateAndPrefixStringValue().
  */
 #if JSONCPP_USING_SECURE_MEMORY
-static inline void releasePrefixedStringValue(char* value)
-{
+static inline void releasePrefixedStringValue(char* value) {
   unsigned length = 0;
   char const* valueDecoded;
   decodePrefixedString(true, value, &length, &valueDecoded);
@@ -167,20 +159,17 @@ static inline void releasePrefixedStringValue(char* value)
   memset(value, 0, size);
   free(value);
 }
-static inline void releaseStringValue(char* value, unsigned length)
-{
+static inline void releaseStringValue(char* value, unsigned length) {
   // length==0 => we allocated the strings memory
-  size_t size = (length == 0) ? strlen(value) : length;
+  size_t size = (length==0) ? strlen(value) : length;
   memset(value, 0, size);
   free(value);
 }
-#else  // !JSONCPP_USING_SECURE_MEMORY
-static inline void releasePrefixedStringValue(char* value)
-{
+#else // !JSONCPP_USING_SECURE_MEMORY
+static inline void releasePrefixedStringValue(char* value) {
   free(value);
 }
-static inline void releaseStringValue(char* value, unsigned)
-{
+static inline void releaseStringValue(char* value, unsigned) {
   free(value);
 }
 #endif // JSONCPP_USING_SECURE_MEMORY
@@ -196,30 +185,26 @@ static inline void releaseStringValue(char* value, unsigned)
 // //////////////////////////////////////////////////////////////////
 #if !defined(JSON_IS_AMALGAMATION)
 
-#  include "json_valueiterator.inl"
+#include "json_valueiterator.inl"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
 namespace Json {
 
 Exception::Exception(JSONCPP_STRING const& msg)
   : msg_(msg)
-{
-}
+{}
 Exception::~Exception() JSONCPP_NOEXCEPT
-{
-}
+{}
 char const* Exception::what() const JSONCPP_NOEXCEPT
 {
-  return this->msg_.c_str();
+  return msg_.c_str();
 }
 RuntimeError::RuntimeError(JSONCPP_STRING const& msg)
   : Exception(msg)
-{
-}
+{}
 LogicError::LogicError(JSONCPP_STRING const& msg)
   : Exception(msg)
-{
-}
+{}
 JSONCPP_NORETURN void throwRuntimeError(JSONCPP_STRING const& msg)
 {
   throw RuntimeError(msg);
@@ -237,29 +222,25 @@ JSONCPP_NORETURN void throwLogicError(JSONCPP_STRING const& msg)
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-Value::CommentInfo::CommentInfo()
-  : comment_(0)
-{
-}
+Value::CommentInfo::CommentInfo() : comment_(0)
+{}
 
-Value::CommentInfo::~CommentInfo()
-{
-  if (this->comment_)
-    releaseStringValue(this->comment_, 0u);
+Value::CommentInfo::~CommentInfo() {
+  if (comment_)
+    releaseStringValue(comment_, 0u);
 }
 
-void Value::CommentInfo::setComment(const char* text, size_t len)
-{
-  if (this->comment_) {
-    releaseStringValue(this->comment_, 0u);
-    this->comment_ = 0;
+void Value::CommentInfo::setComment(const char* text, size_t len) {
+  if (comment_) {
+    releaseStringValue(comment_, 0u);
+    comment_ = 0;
   }
   JSON_ASSERT(text != 0);
   JSON_ASSERT_MESSAGE(
-    text[0] == '\0' || text[0] == '/',
-    "in Json::Value::setComment(): Comments must start with /");
+      text[0] == '\0' || text[0] == '/',
+      "in Json::Value::setComment(): Comments must start with /");
   // It seems that /**/ style comments are acceptable as well.
-  this->comment_ = duplicateStringValue(text, len);
+  comment_ = duplicateStringValue(text, len);
 }
 
 // //////////////////////////////////////////////////////////////////
@@ -273,130 +254,91 @@ void Value::CommentInfo::setComment(const char* text, size_t len)
 // Notes: policy_ indicates if the string was allocated when
 // a string is stored.
 
-Value::CZString::CZString(ArrayIndex aindex)
-  : cstr_(0)
-  , index_(aindex)
-{
-}
+Value::CZString::CZString(ArrayIndex aindex) : cstr_(0), index_(aindex) {}
 
-Value::CZString::CZString(char const* str, unsigned ulength,
-                          DuplicationPolicy allocate)
-  : cstr_(str)
-{
+Value::CZString::CZString(char const* str, unsigned ulength, DuplicationPolicy allocate)
+    : cstr_(str) {
   // allocate != duplicate
-  this->storage_.policy_ = allocate & 0x3;
-  this->storage_.length_ = ulength & 0x3FFFFFFF;
+  storage_.policy_ = allocate & 0x3;
+  storage_.length_ = ulength & 0x3FFFFFFF;
 }
 
-Value::CZString::CZString(const CZString& other)
-{
-  this->cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0
-                   ? duplicateStringValue(other.cstr_, other.storage_.length_)
-                   : other.cstr_);
-  this->storage_.policy_ =
-    static_cast<unsigned>(
-      other.cstr_ ? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
-                         noDuplication
-                       ? noDuplication
-                       : duplicate)
-                  : static_cast<DuplicationPolicy>(other.storage_.policy_)) &
-    3U;
-  this->storage_.length_ = other.storage_.length_;
+Value::CZString::CZString(const CZString& other) {
+  cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0
+				 ? duplicateStringValue(other.cstr_, other.storage_.length_)
+				 : other.cstr_);
+  storage_.policy_ = static_cast<unsigned>(other.cstr_
+                 ? (static_cast<DuplicationPolicy>(other.storage_.policy_) == noDuplication
+                     ? noDuplication : duplicate)
+                 : static_cast<DuplicationPolicy>(other.storage_.policy_)) & 3U;
+  storage_.length_ = other.storage_.length_;
 }
 
 #if JSON_HAS_RVALUE_REFERENCES
 Value::CZString::CZString(CZString&& other)
-  : cstr_(other.cstr_)
-  , index_(other.index_)
-{
+  : cstr_(other.cstr_), index_(other.index_) {
   other.cstr_ = nullptr;
 }
 #endif
 
-Value::CZString::~CZString()
-{
-  if (this->cstr_ && this->storage_.policy_ == duplicate) {
-    releaseStringValue(const_cast<char*>(this->cstr_),
-                       this->storage_.length_ +
-                         1u); //+1 for null terminating character for sake of
-                              //completeness but not actually necessary
+Value::CZString::~CZString() {
+  if (cstr_ && storage_.policy_ == duplicate) {
+	  releaseStringValue(const_cast<char*>(cstr_), storage_.length_ + 1u); //+1 for null terminating character for sake of completeness but not actually necessary
   }
 }
 
-void Value::CZString::swap(CZString& other)
-{
-  std::swap(this->cstr_, other.cstr_);
-  std::swap(this->index_, other.index_);
+void Value::CZString::swap(CZString& other) {
+  std::swap(cstr_, other.cstr_);
+  std::swap(index_, other.index_);
 }
 
-Value::CZString& Value::CZString::operator=(const CZString& other)
-{
-  this->cstr_ = other.cstr_;
-  this->index_ = other.index_;
+Value::CZString& Value::CZString::operator=(const CZString& other) {
+  cstr_ = other.cstr_;
+  index_ = other.index_;
   return *this;
 }
 
 #if JSON_HAS_RVALUE_REFERENCES
-Value::CZString& Value::CZString::operator=(CZString&& other)
-{
-  this->cstr_ = other.cstr_;
-  this->index_ = other.index_;
+Value::CZString& Value::CZString::operator=(CZString&& other) {
+  cstr_ = other.cstr_;
+  index_ = other.index_;
   other.cstr_ = nullptr;
   return *this;
 }
 #endif
 
-bool Value::CZString::operator<(const CZString& other) const
-{
-  if (!this->cstr_)
-    return this->index_ < other.index_;
-  // return strcmp(cstr_, other.cstr_) < 0;
+bool Value::CZString::operator<(const CZString& other) const {
+  if (!cstr_) return index_ < other.index_;
+  //return strcmp(cstr_, other.cstr_) < 0;
   // Assume both are strings.
   unsigned this_len = this->storage_.length_;
   unsigned other_len = other.storage_.length_;
   unsigned min_len = std::min<unsigned>(this_len, other_len);
   JSON_ASSERT(this->cstr_ && other.cstr_);
   int comp = memcmp(this->cstr_, other.cstr_, min_len);
-  if (comp < 0)
-    return true;
-  if (comp > 0)
-    return false;
+  if (comp < 0) return true;
+  if (comp > 0) return false;
   return (this_len < other_len);
 }
 
-bool Value::CZString::operator==(const CZString& other) const
-{
-  if (!this->cstr_)
-    return this->index_ == other.index_;
-  // return strcmp(cstr_, other.cstr_) == 0;
+bool Value::CZString::operator==(const CZString& other) const {
+  if (!cstr_) return index_ == other.index_;
+  //return strcmp(cstr_, other.cstr_) == 0;
   // Assume both are strings.
   unsigned this_len = this->storage_.length_;
   unsigned other_len = other.storage_.length_;
-  if (this_len != other_len)
-    return false;
+  if (this_len != other_len) return false;
   JSON_ASSERT(this->cstr_ && other.cstr_);
   int comp = memcmp(this->cstr_, other.cstr_, this_len);
   return comp == 0;
 }
 
-ArrayIndex Value::CZString::index() const
-{
-  return this->index_;
-}
+ArrayIndex Value::CZString::index() const { return index_; }
 
-// const char* Value::CZString::c_str() const { return cstr_; }
-const char* Value::CZString::data() const
-{
-  return this->cstr_;
-}
-unsigned Value::CZString::length() const
-{
-  return this->storage_.length_;
-}
-bool Value::CZString::isStaticString() const
-{
-  return this->storage_.policy_ == noDuplication;
-}
+//const char* Value::CZString::c_str() const { return cstr_; }
+const char* Value::CZString::data() const { return cstr_; }
+unsigned Value::CZString::length() const { return storage_.length_; }
+bool Value::CZString::isStaticString() const { return storage_.policy_ == noDuplication; }
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -410,238 +352,210 @@ bool Value::CZString::isStaticString() const
  * memset( this, 0, sizeof(Value) )
  * This optimization is used in ValueInternalMap fast allocator.
  */
-Value::Value(ValueType vtype)
-{
+Value::Value(ValueType vtype) {
   static char const emptyString[] = "";
-  this->initBasic(vtype);
+  initBasic(vtype);
   switch (vtype) {
-    case nullValue:
-      break;
-    case intValue:
-    case uintValue:
-      this->value_.int_ = 0;
-      break;
-    case realValue:
-      this->value_.real_ = 0.0;
-      break;
-    case stringValue:
-      // allocated_ == false, so this is safe.
-      this->value_.string_ =
-        const_cast<char*>(static_cast<char const*>(emptyString));
-      break;
-    case arrayValue:
-    case objectValue:
-      this->value_.map_ = new ObjectValues();
-      break;
-    case booleanValue:
-      this->value_.bool_ = false;
-      break;
-    default:
-      JSON_ASSERT_UNREACHABLE;
+  case nullValue:
+    break;
+  case intValue:
+  case uintValue:
+    value_.int_ = 0;
+    break;
+  case realValue:
+    value_.real_ = 0.0;
+    break;
+  case stringValue:
+    // allocated_ == false, so this is safe.
+    value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
+    break;
+  case arrayValue:
+  case objectValue:
+    value_.map_ = new ObjectValues();
+    break;
+  case booleanValue:
+    value_.bool_ = false;
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
   }
 }
 
-Value::Value(Int value)
-{
-  this->initBasic(intValue);
-  this->value_.int_ = value;
+Value::Value(Int value) {
+  initBasic(intValue);
+  value_.int_ = value;
 }
 
-Value::Value(UInt value)
-{
-  this->initBasic(uintValue);
-  this->value_.uint_ = value;
+Value::Value(UInt value) {
+  initBasic(uintValue);
+  value_.uint_ = value;
 }
 #if defined(JSON_HAS_INT64)
-Value::Value(Int64 value)
-{
-  this->initBasic(intValue);
-  this->value_.int_ = value;
+Value::Value(Int64 value) {
+  initBasic(intValue);
+  value_.int_ = value;
 }
-Value::Value(UInt64 value)
-{
-  this->initBasic(uintValue);
-  this->value_.uint_ = value;
+Value::Value(UInt64 value) {
+  initBasic(uintValue);
+  value_.uint_ = value;
 }
 #endif // defined(JSON_HAS_INT64)
 
-Value::Value(double value)
-{
-  this->initBasic(realValue);
-  this->value_.real_ = value;
+Value::Value(double value) {
+  initBasic(realValue);
+  value_.real_ = value;
 }
 
-Value::Value(const char* value)
-{
-  this->initBasic(stringValue, true);
+Value::Value(const char* value) {
+  initBasic(stringValue, true);
   JSON_ASSERT_MESSAGE(value != NULL, "Null Value Passed to Value Constructor");
-  this->value_.string_ =
-    duplicateAndPrefixStringValue(value, static_cast<unsigned>(strlen(value)));
+  value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(strlen(value)));
 }
 
-Value::Value(const char* beginValue, const char* endValue)
-{
-  this->initBasic(stringValue, true);
-  this->value_.string_ = duplicateAndPrefixStringValue(
-    beginValue, static_cast<unsigned>(endValue - beginValue));
+Value::Value(const char* beginValue, const char* endValue) {
+  initBasic(stringValue, true);
+  value_.string_ =
+      duplicateAndPrefixStringValue(beginValue, static_cast<unsigned>(endValue - beginValue));
 }
 
-Value::Value(const JSONCPP_STRING& value)
-{
-  this->initBasic(stringValue, true);
-  this->value_.string_ = duplicateAndPrefixStringValue(
-    value.data(), static_cast<unsigned>(value.length()));
+Value::Value(const JSONCPP_STRING& value) {
+  initBasic(stringValue, true);
+  value_.string_ =
+      duplicateAndPrefixStringValue(value.data(), static_cast<unsigned>(value.length()));
 }
 
-Value::Value(const StaticString& value)
-{
-  this->initBasic(stringValue);
-  this->value_.string_ = const_cast<char*>(value.c_str());
+Value::Value(const StaticString& value) {
+  initBasic(stringValue);
+  value_.string_ = const_cast<char*>(value.c_str());
 }
 
 #ifdef JSON_USE_CPPTL
-Value::Value(const CppTL::ConstString& value)
-{
+Value::Value(const CppTL::ConstString& value) {
   initBasic(stringValue, true);
-  value_.string_ = duplicateAndPrefixStringValue(
-    value, static_cast<unsigned>(value.length()));
+  value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(value.length()));
 }
 #endif
 
-Value::Value(bool value)
-{
-  this->initBasic(booleanValue);
-  this->value_.bool_ = value;
+Value::Value(bool value) {
+  initBasic(booleanValue);
+  value_.bool_ = value;
 }
 
 Value::Value(Value const& other)
-  : type_(other.type_)
-  , allocated_(false)
-  , comments_(0)
-  , start_(other.start_)
-  , limit_(other.limit_)
-{
-  switch (this->type_) {
-    case nullValue:
-    case intValue:
-    case uintValue:
-    case realValue:
-    case booleanValue:
-      this->value_ = other.value_;
-      break;
-    case stringValue:
-      if (other.value_.string_ && other.allocated_) {
-        unsigned len;
-        char const* str;
-        decodePrefixedString(other.allocated_, other.value_.string_, &len,
-                             &str);
-        this->value_.string_ = duplicateAndPrefixStringValue(str, len);
-        this->allocated_ = true;
-      } else {
-        this->value_.string_ = other.value_.string_;
-        this->allocated_ = false;
-      }
-      break;
-    case arrayValue:
-    case objectValue:
-      this->value_.map_ = new ObjectValues(*other.value_.map_);
-      break;
-    default:
-      JSON_ASSERT_UNREACHABLE;
+    : type_(other.type_), allocated_(false)
+      ,
+      comments_(0), start_(other.start_), limit_(other.limit_)
+{
+  switch (type_) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+    value_ = other.value_;
+    break;
+  case stringValue:
+    if (other.value_.string_ && other.allocated_) {
+      unsigned len;
+      char const* str;
+      decodePrefixedString(other.allocated_, other.value_.string_,
+          &len, &str);
+      value_.string_ = duplicateAndPrefixStringValue(str, len);
+      allocated_ = true;
+    } else {
+      value_.string_ = other.value_.string_;
+      allocated_ = false;
+    }
+    break;
+  case arrayValue:
+  case objectValue:
+    value_.map_ = new ObjectValues(*other.value_.map_);
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
   }
   if (other.comments_) {
-    this->comments_ = new CommentInfo[numberOfCommentPlacement];
+    comments_ = new CommentInfo[numberOfCommentPlacement];
     for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
       const CommentInfo& otherComment = other.comments_[comment];
       if (otherComment.comment_)
-        this->comments_[comment].setComment(otherComment.comment_,
-                                            strlen(otherComment.comment_));
+        comments_[comment].setComment(
+            otherComment.comment_, strlen(otherComment.comment_));
     }
   }
 }
 
 #if JSON_HAS_RVALUE_REFERENCES
 // Move constructor
-Value::Value(Value&& other)
-{
-  this->initBasic(nullValue);
-  this->swap(other);
+Value::Value(Value&& other) {
+  initBasic(nullValue);
+  swap(other);
 }
 #endif
 
-Value::~Value()
-{
-  switch (this->type_) {
-    case nullValue:
-    case intValue:
-    case uintValue:
-    case realValue:
-    case booleanValue:
-      break;
-    case stringValue:
-      if (this->allocated_)
-        releasePrefixedStringValue(this->value_.string_);
-      break;
-    case arrayValue:
-    case objectValue:
-      delete this->value_.map_;
-      break;
-    default:
-      JSON_ASSERT_UNREACHABLE;
+Value::~Value() {
+  switch (type_) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+    break;
+  case stringValue:
+    if (allocated_)
+      releasePrefixedStringValue(value_.string_);
+    break;
+  case arrayValue:
+  case objectValue:
+    delete value_.map_;
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
   }
 
-  delete[] this->comments_;
+  delete[] comments_;
 
-  this->value_.uint_ = 0;
+  value_.uint_ = 0;
 }
 
-Value& Value::operator=(Value other)
-{
-  this->swap(other);
+Value& Value::operator=(Value other) {
+  swap(other);
   return *this;
 }
 
-void Value::swapPayload(Value& other)
-{
-  ValueType temp = this->type_;
-  this->type_ = other.type_;
+void Value::swapPayload(Value& other) {
+  ValueType temp = type_;
+  type_ = other.type_;
   other.type_ = temp;
-  std::swap(this->value_, other.value_);
-  int temp2 = this->allocated_;
-  this->allocated_ = other.allocated_;
+  std::swap(value_, other.value_);
+  int temp2 = allocated_;
+  allocated_ = other.allocated_;
   other.allocated_ = temp2 & 0x1;
 }
 
-void Value::copyPayload(const Value& other)
-{
-  this->type_ = other.type_;
-  this->value_ = other.value_;
-  this->allocated_ = other.allocated_;
+void Value::copyPayload(const Value& other) {
+  type_ = other.type_;
+  value_ = other.value_;
+  allocated_ = other.allocated_;
 }
 
-void Value::swap(Value& other)
-{
-  this->swapPayload(other);
-  std::swap(this->comments_, other.comments_);
-  std::swap(this->start_, other.start_);
-  std::swap(this->limit_, other.limit_);
+void Value::swap(Value& other) {
+  swapPayload(other);
+  std::swap(comments_, other.comments_);
+  std::swap(start_, other.start_);
+  std::swap(limit_, other.limit_);
 }
 
-void Value::copy(const Value& other)
-{
-  this->copyPayload(other);
-  this->comments_ = other.comments_;
-  this->start_ = other.start_;
-  this->limit_ = other.limit_;
+void Value::copy(const Value& other) {
+  copyPayload(other);
+  comments_ = other.comments_;
+  start_ = other.start_;
+  limit_ = other.limit_;
 }
 
-ValueType Value::type() const
-{
-  return this->type_;
-}
+ValueType Value::type() const { return type_; }
 
-int Value::compare(const Value& other) const
-{
+int Value::compare(const Value& other) const {
   if (*this < other)
     return -1;
   if (*this > other)
@@ -649,568 +563,509 @@ int Value::compare(const Value& other) const
   return 0;
 }
 
-bool Value::operator<(const Value& other) const
-{
-  int typeDelta = this->type_ - other.type_;
+bool Value::operator<(const Value& other) const {
+  int typeDelta = type_ - other.type_;
   if (typeDelta)
     return typeDelta < 0 ? true : false;
-  switch (this->type_) {
-    case nullValue:
-      return false;
-    case intValue:
-      return this->value_.int_ < other.value_.int_;
-    case uintValue:
-      return this->value_.uint_ < other.value_.uint_;
-    case realValue:
-      return this->value_.real_ < other.value_.real_;
-    case booleanValue:
-      return this->value_.bool_ < other.value_.bool_;
-    case stringValue: {
-      if ((this->value_.string_ == 0) || (other.value_.string_ == 0)) {
-        if (other.value_.string_)
-          return true;
-        else
-          return false;
-      }
-      unsigned this_len;
-      unsigned other_len;
-      char const* this_str;
-      char const* other_str;
-      decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
-                           &this_str);
-      decodePrefixedString(other.allocated_, other.value_.string_, &other_len,
-                           &other_str);
-      unsigned min_len = std::min<unsigned>(this_len, other_len);
-      JSON_ASSERT(this_str && other_str);
-      int comp = memcmp(this_str, other_str, min_len);
-      if (comp < 0)
-        return true;
-      if (comp > 0)
-        return false;
-      return (this_len < other_len);
-    }
-    case arrayValue:
-    case objectValue: {
-      int delta = int(this->value_.map_->size() - other.value_.map_->size());
-      if (delta)
-        return delta < 0;
-      return (*this->value_.map_) < (*other.value_.map_);
+  switch (type_) {
+  case nullValue:
+    return false;
+  case intValue:
+    return value_.int_ < other.value_.int_;
+  case uintValue:
+    return value_.uint_ < other.value_.uint_;
+  case realValue:
+    return value_.real_ < other.value_.real_;
+  case booleanValue:
+    return value_.bool_ < other.value_.bool_;
+  case stringValue:
+  {
+    if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
+      if (other.value_.string_) return true;
+      else return false;
     }
-    default:
-      JSON_ASSERT_UNREACHABLE;
+    unsigned this_len;
+    unsigned other_len;
+    char const* this_str;
+    char const* other_str;
+    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
+    decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
+    unsigned min_len = std::min<unsigned>(this_len, other_len);
+    JSON_ASSERT(this_str && other_str);
+    int comp = memcmp(this_str, other_str, min_len);
+    if (comp < 0) return true;
+    if (comp > 0) return false;
+    return (this_len < other_len);
+  }
+  case arrayValue:
+  case objectValue: {
+    int delta = int(value_.map_->size() - other.value_.map_->size());
+    if (delta)
+      return delta < 0;
+    return (*value_.map_) < (*other.value_.map_);
+  }
+  default:
+    JSON_ASSERT_UNREACHABLE;
   }
   return false; // unreachable
 }
 
-bool Value::operator<=(const Value& other) const
-{
-  return !(other < *this);
-}
+bool Value::operator<=(const Value& other) const { return !(other < *this); }
 
-bool Value::operator>=(const Value& other) const
-{
-  return !(*this < other);
-}
+bool Value::operator>=(const Value& other) const { return !(*this < other); }
 
-bool Value::operator>(const Value& other) const
-{
-  return other < *this;
-}
+bool Value::operator>(const Value& other) const { return other < *this; }
 
-bool Value::operator==(const Value& other) const
-{
+bool Value::operator==(const Value& other) const {
   // if ( type_ != other.type_ )
   // GCC 2.95.3 says:
   // attempt to take address of bit-field structure member `Json::Value::type_'
   // Beats me, but a temp solves the problem.
   int temp = other.type_;
-  if (this->type_ != temp)
+  if (type_ != temp)
     return false;
-  switch (this->type_) {
-    case nullValue:
-      return true;
-    case intValue:
-      return this->value_.int_ == other.value_.int_;
-    case uintValue:
-      return this->value_.uint_ == other.value_.uint_;
-    case realValue:
-      return this->value_.real_ == other.value_.real_;
-    case booleanValue:
-      return this->value_.bool_ == other.value_.bool_;
-    case stringValue: {
-      if ((this->value_.string_ == 0) || (other.value_.string_ == 0)) {
-        return (this->value_.string_ == other.value_.string_);
-      }
-      unsigned this_len;
-      unsigned other_len;
-      char const* this_str;
-      char const* other_str;
-      decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
-                           &this_str);
-      decodePrefixedString(other.allocated_, other.value_.string_, &other_len,
-                           &other_str);
-      if (this_len != other_len)
-        return false;
-      JSON_ASSERT(this_str && other_str);
-      int comp = memcmp(this_str, other_str, this_len);
-      return comp == 0;
+  switch (type_) {
+  case nullValue:
+    return true;
+  case intValue:
+    return value_.int_ == other.value_.int_;
+  case uintValue:
+    return value_.uint_ == other.value_.uint_;
+  case realValue:
+    return value_.real_ == other.value_.real_;
+  case booleanValue:
+    return value_.bool_ == other.value_.bool_;
+  case stringValue:
+  {
+    if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
+      return (value_.string_ == other.value_.string_);
     }
-    case arrayValue:
-    case objectValue:
-      return this->value_.map_->size() == other.value_.map_->size() &&
-        (*this->value_.map_) == (*other.value_.map_);
-    default:
-      JSON_ASSERT_UNREACHABLE;
+    unsigned this_len;
+    unsigned other_len;
+    char const* this_str;
+    char const* other_str;
+    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
+    decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
+    if (this_len != other_len) return false;
+    JSON_ASSERT(this_str && other_str);
+    int comp = memcmp(this_str, other_str, this_len);
+    return comp == 0;
+  }
+  case arrayValue:
+  case objectValue:
+    return value_.map_->size() == other.value_.map_->size() &&
+           (*value_.map_) == (*other.value_.map_);
+  default:
+    JSON_ASSERT_UNREACHABLE;
   }
   return false; // unreachable
 }
 
-bool Value::operator!=(const Value& other) const
-{
-  return !(*this == other);
-}
+bool Value::operator!=(const Value& other) const { return !(*this == other); }
 
-const char* Value::asCString() const
-{
+const char* Value::asCString() const {
   JSON_ASSERT_MESSAGE(type_ == stringValue,
                       "in Json::Value::asCString(): requires stringValue");
-  if (this->value_.string_ == 0)
-    return 0;
+  if (value_.string_ == 0) return 0;
   unsigned this_len;
   char const* this_str;
-  decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
-                       &this_str);
+  decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
   return this_str;
 }
 
 #if JSONCPP_USING_SECURE_MEMORY
-unsigned Value::getCStringLength() const
-{
+unsigned Value::getCStringLength() const {
   JSON_ASSERT_MESSAGE(type_ == stringValue,
-                      "in Json::Value::asCString(): requires stringValue");
-  if (value_.string_ == 0)
-    return 0;
+	                  "in Json::Value::asCString(): requires stringValue");
+  if (value_.string_ == 0) return 0;
   unsigned this_len;
   char const* this_str;
-  decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
-                       &this_str);
+  decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
   return this_len;
 }
 #endif
 
-bool Value::getString(char const** str, char const** cend) const
-{
-  if (this->type_ != stringValue)
-    return false;
-  if (this->value_.string_ == 0)
-    return false;
+bool Value::getString(char const** str, char const** cend) const {
+  if (type_ != stringValue) return false;
+  if (value_.string_ == 0) return false;
   unsigned length;
   decodePrefixedString(this->allocated_, this->value_.string_, &length, str);
   *cend = *str + length;
   return true;
 }
 
-JSONCPP_STRING Value::asString() const
-{
-  switch (this->type_) {
-    case nullValue:
-      return "";
-    case stringValue: {
-      if (this->value_.string_ == 0)
-        return "";
-      unsigned this_len;
-      char const* this_str;
-      decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
-                           &this_str);
-      return JSONCPP_STRING(this_str, this_len);
-    }
-    case booleanValue:
-      return this->value_.bool_ ? "true" : "false";
-    case intValue:
-      return valueToString(this->value_.int_);
-    case uintValue:
-      return valueToString(this->value_.uint_);
-    case realValue:
-      return valueToString(this->value_.real_);
-    default:
-      JSON_FAIL_MESSAGE("Type is not convertible to string");
+JSONCPP_STRING Value::asString() const {
+  switch (type_) {
+  case nullValue:
+    return "";
+  case stringValue:
+  {
+    if (value_.string_ == 0) return "";
+    unsigned this_len;
+    char const* this_str;
+    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
+    return JSONCPP_STRING(this_str, this_len);
+  }
+  case booleanValue:
+    return value_.bool_ ? "true" : "false";
+  case intValue:
+    return valueToString(value_.int_);
+  case uintValue:
+    return valueToString(value_.uint_);
+  case realValue:
+    return valueToString(value_.real_);
+  default:
+    JSON_FAIL_MESSAGE("Type is not convertible to string");
   }
 }
 
 #ifdef JSON_USE_CPPTL
-CppTL::ConstString Value::asConstString() const
-{
+CppTL::ConstString Value::asConstString() const {
   unsigned len;
   char const* str;
-  decodePrefixedString(allocated_, value_.string_, &len, &str);
+  decodePrefixedString(allocated_, value_.string_,
+      &len, &str);
   return CppTL::ConstString(str, len);
 }
 #endif
 
-Value::Int Value::asInt() const
-{
-  switch (this->type_) {
-    case intValue:
-      JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
-      return Int(this->value_.int_);
-    case uintValue:
-      JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
-      return Int(this->value_.uint_);
-    case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
-                          "double out of Int range");
-      return Int(this->value_.real_);
-    case nullValue:
-      return 0;
-    case booleanValue:
-      return this->value_.bool_ ? 1 : 0;
-    default:
-      break;
+Value::Int Value::asInt() const {
+  switch (type_) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+    return Int(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+    return Int(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
+                        "double out of Int range");
+    return Int(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to Int.");
 }
 
-Value::UInt Value::asUInt() const
-{
-  switch (this->type_) {
-    case intValue:
-      JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
-      return UInt(this->value_.int_);
-    case uintValue:
-      JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
-      return UInt(this->value_.uint_);
-    case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
-                          "double out of UInt range");
-      return UInt(this->value_.real_);
-    case nullValue:
-      return 0;
-    case booleanValue:
-      return this->value_.bool_ ? 1 : 0;
-    default:
-      break;
+Value::UInt Value::asUInt() const {
+  switch (type_) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+    return UInt(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+    return UInt(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
+                        "double out of UInt range");
+    return UInt(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
 }
 
 #if defined(JSON_HAS_INT64)
 
-Value::Int64 Value::asInt64() const
-{
-  switch (this->type_) {
-    case intValue:
-      return Int64(this->value_.int_);
-    case uintValue:
-      JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
-      return Int64(this->value_.uint_);
-    case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
-                          "double out of Int64 range");
-      return Int64(this->value_.real_);
-    case nullValue:
-      return 0;
-    case booleanValue:
-      return this->value_.bool_ ? 1 : 0;
-    default:
-      break;
+Value::Int64 Value::asInt64() const {
+  switch (type_) {
+  case intValue:
+    return Int64(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+    return Int64(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
+                        "double out of Int64 range");
+    return Int64(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
 }
 
-Value::UInt64 Value::asUInt64() const
-{
-  switch (this->type_) {
-    case intValue:
-      JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
-      return UInt64(this->value_.int_);
-    case uintValue:
-      return UInt64(this->value_.uint_);
-    case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
-                          "double out of UInt64 range");
-      return UInt64(this->value_.real_);
-    case nullValue:
-      return 0;
-    case booleanValue:
-      return this->value_.bool_ ? 1 : 0;
-    default:
-      break;
+Value::UInt64 Value::asUInt64() const {
+  switch (type_) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+    return UInt64(value_.int_);
+  case uintValue:
+    return UInt64(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
+                        "double out of UInt64 range");
+    return UInt64(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
 }
 #endif // if defined(JSON_HAS_INT64)
 
-LargestInt Value::asLargestInt() const
-{
+LargestInt Value::asLargestInt() const {
 #if defined(JSON_NO_INT64)
   return asInt();
 #else
-  return this->asInt64();
+  return asInt64();
 #endif
 }
 
-LargestUInt Value::asLargestUInt() const
-{
+LargestUInt Value::asLargestUInt() const {
 #if defined(JSON_NO_INT64)
   return asUInt();
 #else
-  return this->asUInt64();
+  return asUInt64();
 #endif
 }
 
-double Value::asDouble() const
-{
-  switch (this->type_) {
-    case intValue:
-      return static_cast<double>(this->value_.int_);
-    case uintValue:
+double Value::asDouble() const {
+  switch (type_) {
+  case intValue:
+    return static_cast<double>(value_.int_);
+  case uintValue:
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return static_cast<double>(this->value_.uint_);
+    return static_cast<double>(value_.uint_);
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return integerToDouble(value_.uint_);
+    return integerToDouble(value_.uint_);
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    case realValue:
-      return this->value_.real_;
-    case nullValue:
-      return 0.0;
-    case booleanValue:
-      return this->value_.bool_ ? 1.0 : 0.0;
-    default:
-      break;
+  case realValue:
+    return value_.real_;
+  case nullValue:
+    return 0.0;
+  case booleanValue:
+    return value_.bool_ ? 1.0 : 0.0;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to double.");
 }
 
-float Value::asFloat() const
-{
-  switch (this->type_) {
-    case intValue:
-      return static_cast<float>(this->value_.int_);
-    case uintValue:
+float Value::asFloat() const {
+  switch (type_) {
+  case intValue:
+    return static_cast<float>(value_.int_);
+  case uintValue:
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return static_cast<float>(this->value_.uint_);
+    return static_cast<float>(value_.uint_);
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      // This can fail (silently?) if the value is bigger than MAX_FLOAT.
-      return static_cast<float>(integerToDouble(value_.uint_));
+    // This can fail (silently?) if the value is bigger than MAX_FLOAT.
+    return static_cast<float>(integerToDouble(value_.uint_));
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    case realValue:
-      return static_cast<float>(this->value_.real_);
-    case nullValue:
-      return 0.0;
-    case booleanValue:
-      return this->value_.bool_ ? 1.0f : 0.0f;
-    default:
-      break;
+  case realValue:
+    return static_cast<float>(value_.real_);
+  case nullValue:
+    return 0.0;
+  case booleanValue:
+    return value_.bool_ ? 1.0f : 0.0f;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to float.");
 }
 
-bool Value::asBool() const
-{
-  switch (this->type_) {
-    case booleanValue:
-      return this->value_.bool_;
-    case nullValue:
-      return false;
-    case intValue:
-      return this->value_.int_ ? true : false;
-    case uintValue:
-      return this->value_.uint_ ? true : false;
-    case realValue:
-      // This is kind of strange. Not recommended.
-      return (this->value_.real_ != 0.0) ? true : false;
-    default:
-      break;
+bool Value::asBool() const {
+  switch (type_) {
+  case booleanValue:
+    return value_.bool_;
+  case nullValue:
+    return false;
+  case intValue:
+    return value_.int_ ? true : false;
+  case uintValue:
+    return value_.uint_ ? true : false;
+  case realValue:
+    // This is kind of strange. Not recommended.
+    return (value_.real_ != 0.0) ? true : false;
+  default:
+    break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to bool.");
 }
 
-bool Value::isConvertibleTo(ValueType other) const
-{
+bool Value::isConvertibleTo(ValueType other) const {
   switch (other) {
-    case nullValue:
-      return (this->isNumeric() && this->asDouble() == 0.0) ||
-        (this->type_ == booleanValue && this->value_.bool_ == false) ||
-        (this->type_ == stringValue && this->asString().empty()) ||
-        (this->type_ == arrayValue && this->value_.map_->size() == 0) ||
-        (this->type_ == objectValue && this->value_.map_->size() == 0) ||
-        this->type_ == nullValue;
-    case intValue:
-      return this->isInt() ||
-        (this->type_ == realValue &&
-         InRange(this->value_.real_, minInt, maxInt)) ||
-        this->type_ == booleanValue || this->type_ == nullValue;
-    case uintValue:
-      return this->isUInt() ||
-        (this->type_ == realValue &&
-         InRange(this->value_.real_, 0, maxUInt)) ||
-        this->type_ == booleanValue || this->type_ == nullValue;
-    case realValue:
-      return this->isNumeric() || this->type_ == booleanValue ||
-        this->type_ == nullValue;
-    case booleanValue:
-      return this->isNumeric() || this->type_ == booleanValue ||
-        this->type_ == nullValue;
-    case stringValue:
-      return this->isNumeric() || this->type_ == booleanValue ||
-        this->type_ == stringValue || this->type_ == nullValue;
-    case arrayValue:
-      return this->type_ == arrayValue || this->type_ == nullValue;
-    case objectValue:
-      return this->type_ == objectValue || this->type_ == nullValue;
+  case nullValue:
+    return (isNumeric() && asDouble() == 0.0) ||
+           (type_ == booleanValue && value_.bool_ == false) ||
+           (type_ == stringValue && asString().empty()) ||
+           (type_ == arrayValue && value_.map_->size() == 0) ||
+           (type_ == objectValue && value_.map_->size() == 0) ||
+           type_ == nullValue;
+  case intValue:
+    return isInt() ||
+           (type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||
+           type_ == booleanValue || type_ == nullValue;
+  case uintValue:
+    return isUInt() ||
+           (type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||
+           type_ == booleanValue || type_ == nullValue;
+  case realValue:
+    return isNumeric() || type_ == booleanValue || type_ == nullValue;
+  case booleanValue:
+    return isNumeric() || type_ == booleanValue || type_ == nullValue;
+  case stringValue:
+    return isNumeric() || type_ == booleanValue || type_ == stringValue ||
+           type_ == nullValue;
+  case arrayValue:
+    return type_ == arrayValue || type_ == nullValue;
+  case objectValue:
+    return type_ == objectValue || type_ == nullValue;
   }
   JSON_ASSERT_UNREACHABLE;
   return false;
 }
 
 /// Number of values in array or object
-ArrayIndex Value::size() const
-{
-  switch (this->type_) {
-    case nullValue:
-    case intValue:
-    case uintValue:
-    case realValue:
-    case booleanValue:
-    case stringValue:
-      return 0;
-    case arrayValue: // size of the array is highest index + 1
-      if (!this->value_.map_->empty()) {
-        ObjectValues::const_iterator itLast = this->value_.map_->end();
-        --itLast;
-        return (*itLast).first.index() + 1;
-      }
-      return 0;
-    case objectValue:
-      return ArrayIndex(this->value_.map_->size());
+ArrayIndex Value::size() const {
+  switch (type_) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+  case stringValue:
+    return 0;
+  case arrayValue: // size of the array is highest index + 1
+    if (!value_.map_->empty()) {
+      ObjectValues::const_iterator itLast = value_.map_->end();
+      --itLast;
+      return (*itLast).first.index() + 1;
+    }
+    return 0;
+  case objectValue:
+    return ArrayIndex(value_.map_->size());
   }
   JSON_ASSERT_UNREACHABLE;
   return 0; // unreachable;
 }
 
-bool Value::empty() const
-{
-  if (this->isNull() || this->isArray() || this->isObject())
-    return this->size() == 0u;
+bool Value::empty() const {
+  if (isNull() || isArray() || isObject())
+    return size() == 0u;
   else
     return false;
 }
 
-bool Value::operator!() const
-{
-  return this->isNull();
-}
+bool Value::operator!() const { return isNull(); }
 
-void Value::clear()
-{
+void Value::clear() {
   JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
-                        type_ == objectValue,
+                          type_ == objectValue,
                       "in Json::Value::clear(): requires complex value");
-  this->start_ = 0;
-  this->limit_ = 0;
-  switch (this->type_) {
-    case arrayValue:
-    case objectValue:
-      this->value_.map_->clear();
-      break;
-    default:
-      break;
+  start_ = 0;
+  limit_ = 0;
+  switch (type_) {
+  case arrayValue:
+  case objectValue:
+    value_.map_->clear();
+    break;
+  default:
+    break;
   }
 }
 
-void Value::resize(ArrayIndex newSize)
-{
+void Value::resize(ArrayIndex newSize) {
   JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
                       "in Json::Value::resize(): requires arrayValue");
-  if (this->type_ == nullValue)
+  if (type_ == nullValue)
     *this = Value(arrayValue);
-  ArrayIndex oldSize = this->size();
+  ArrayIndex oldSize = size();
   if (newSize == 0)
-    this->clear();
+    clear();
   else if (newSize > oldSize)
     (*this)[newSize - 1];
   else {
     for (ArrayIndex index = newSize; index < oldSize; ++index) {
-      this->value_.map_->erase(index);
+      value_.map_->erase(index);
     }
     JSON_ASSERT(size() == newSize);
   }
 }
 
-Value& Value::operator[](ArrayIndex index)
-{
+Value& Value::operator[](ArrayIndex index) {
   JSON_ASSERT_MESSAGE(
-    type_ == nullValue || type_ == arrayValue,
-    "in Json::Value::operator[](ArrayIndex): requires arrayValue");
-  if (this->type_ == nullValue)
+      type_ == nullValue || type_ == arrayValue,
+      "in Json::Value::operator[](ArrayIndex): requires arrayValue");
+  if (type_ == nullValue)
     *this = Value(arrayValue);
   CZString key(index);
-  ObjectValues::iterator it = this->value_.map_->lower_bound(key);
-  if (it != this->value_.map_->end() && (*it).first == key)
+  ObjectValues::iterator it = value_.map_->lower_bound(key);
+  if (it != value_.map_->end() && (*it).first == key)
     return (*it).second;
 
   ObjectValues::value_type defaultValue(key, nullSingleton());
-  it = this->value_.map_->insert(it, defaultValue);
+  it = value_.map_->insert(it, defaultValue);
   return (*it).second;
 }
 
-Value& Value::operator[](int index)
-{
+Value& Value::operator[](int index) {
   JSON_ASSERT_MESSAGE(
-    index >= 0,
-    "in Json::Value::operator[](int index): index cannot be negative");
+      index >= 0,
+      "in Json::Value::operator[](int index): index cannot be negative");
   return (*this)[ArrayIndex(index)];
 }
 
-const Value& Value::operator[](ArrayIndex index) const
-{
+const Value& Value::operator[](ArrayIndex index) const {
   JSON_ASSERT_MESSAGE(
-    type_ == nullValue || type_ == arrayValue,
-    "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
-  if (this->type_ == nullValue)
+      type_ == nullValue || type_ == arrayValue,
+      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
+  if (type_ == nullValue)
     return nullSingleton();
   CZString key(index);
-  ObjectValues::const_iterator it = this->value_.map_->find(key);
-  if (it == this->value_.map_->end())
+  ObjectValues::const_iterator it = value_.map_->find(key);
+  if (it == value_.map_->end())
     return nullSingleton();
   return (*it).second;
 }
 
-const Value& Value::operator[](int index) const
-{
+const Value& Value::operator[](int index) const {
   JSON_ASSERT_MESSAGE(
-    index >= 0,
-    "in Json::Value::operator[](int index) const: index cannot be negative");
+      index >= 0,
+      "in Json::Value::operator[](int index) const: index cannot be negative");
   return (*this)[ArrayIndex(index)];
 }
 
-void Value::initBasic(ValueType vtype, bool allocated)
-{
-  this->type_ = vtype;
-  this->allocated_ = allocated;
-  this->comments_ = 0;
-  this->start_ = 0;
-  this->limit_ = 0;
+void Value::initBasic(ValueType vtype, bool allocated) {
+  type_ = vtype;
+  allocated_ = allocated;
+  comments_ = 0;
+  start_ = 0;
+  limit_ = 0;
 }
 
 // Access an object value by name, create a null member if it does not exist.
 // @pre Type of '*this' is object or null.
 // @param key is null-terminated.
-Value& Value::resolveReference(const char* key)
-{
+Value& Value::resolveReference(const char* key) {
   JSON_ASSERT_MESSAGE(
-    type_ == nullValue || type_ == objectValue,
-    "in Json::Value::resolveReference(): requires objectValue");
-  if (this->type_ == nullValue)
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::resolveReference(): requires objectValue");
+  if (type_ == nullValue)
     *this = Value(objectValue);
-  CZString actualKey(key, static_cast<unsigned>(strlen(key)),
-                     CZString::noDuplication); // NOTE!
-  ObjectValues::iterator it = this->value_.map_->lower_bound(actualKey);
-  if (it != this->value_.map_->end() && (*it).first == actualKey)
+  CZString actualKey(
+      key, static_cast<unsigned>(strlen(key)), CZString::noDuplication); // NOTE!
+  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
+  if (it != value_.map_->end() && (*it).first == actualKey)
     return (*it).second;
 
   ObjectValues::value_type defaultValue(actualKey, nullSingleton());
-  it = this->value_.map_->insert(it, defaultValue);
+  it = value_.map_->insert(it, defaultValue);
   Value& value = (*it).second;
   return value;
 }
@@ -1219,223 +1074,198 @@ Value& Value::resolveReference(const char* key)
 Value& Value::resolveReference(char const* key, char const* cend)
 {
   JSON_ASSERT_MESSAGE(
-    type_ == nullValue || type_ == objectValue,
-    "in Json::Value::resolveReference(key, end): requires objectValue");
-  if (this->type_ == nullValue)
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::resolveReference(key, end): requires objectValue");
+  if (type_ == nullValue)
     *this = Value(objectValue);
-  CZString actualKey(key, static_cast<unsigned>(cend - key),
-                     CZString::duplicateOnCopy);
-  ObjectValues::iterator it = this->value_.map_->lower_bound(actualKey);
-  if (it != this->value_.map_->end() && (*it).first == actualKey)
+  CZString actualKey(
+      key, static_cast<unsigned>(cend-key), CZString::duplicateOnCopy);
+  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
+  if (it != value_.map_->end() && (*it).first == actualKey)
     return (*it).second;
 
   ObjectValues::value_type defaultValue(actualKey, nullSingleton());
-  it = this->value_.map_->insert(it, defaultValue);
+  it = value_.map_->insert(it, defaultValue);
   Value& value = (*it).second;
   return value;
 }
 
-Value Value::get(ArrayIndex index, const Value& defaultValue) const
-{
+Value Value::get(ArrayIndex index, const Value& defaultValue) const {
   const Value* value = &((*this)[index]);
   return value == &nullSingleton() ? defaultValue : *value;
 }
 
-bool Value::isValidIndex(ArrayIndex index) const
-{
-  return index < this->size();
-}
+bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
 
 Value const* Value::find(char const* key, char const* cend) const
 {
-  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
-                      "in Json::Value::find(key, end, found): requires "
-                      "objectValue or nullValue");
-  if (this->type_ == nullValue)
-    return NULL;
-  CZString actualKey(key, static_cast<unsigned>(cend - key),
-                     CZString::noDuplication);
-  ObjectValues::const_iterator it = this->value_.map_->find(actualKey);
-  if (it == this->value_.map_->end())
-    return NULL;
+  JSON_ASSERT_MESSAGE(
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::find(key, end, found): requires objectValue or nullValue");
+  if (type_ == nullValue) return NULL;
+  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
+  ObjectValues::const_iterator it = value_.map_->find(actualKey);
+  if (it == value_.map_->end()) return NULL;
   return &(*it).second;
 }
 const Value& Value::operator[](const char* key) const
 {
-  Value const* found = this->find(key, key + strlen(key));
-  if (!found)
-    return nullSingleton();
+  Value const* found = find(key, key + strlen(key));
+  if (!found) return nullSingleton();
   return *found;
 }
 Value const& Value::operator[](JSONCPP_STRING const& key) const
 {
-  Value const* found = this->find(key.data(), key.data() + key.length());
-  if (!found)
-    return nullSingleton();
+  Value const* found = find(key.data(), key.data() + key.length());
+  if (!found) return nullSingleton();
   return *found;
 }
 
-Value& Value::operator[](const char* key)
-{
-  return this->resolveReference(key, key + strlen(key));
+Value& Value::operator[](const char* key) {
+  return resolveReference(key, key + strlen(key));
 }
 
-Value& Value::operator[](const JSONCPP_STRING& key)
-{
-  return this->resolveReference(key.data(), key.data() + key.length());
+Value& Value::operator[](const JSONCPP_STRING& key) {
+  return resolveReference(key.data(), key.data() + key.length());
 }
 
-Value& Value::operator[](const StaticString& key)
-{
-  return this->resolveReference(key.c_str());
+Value& Value::operator[](const StaticString& key) {
+  return resolveReference(key.c_str());
 }
 
 #ifdef JSON_USE_CPPTL
-Value& Value::operator[](const CppTL::ConstString& key)
-{
+Value& Value::operator[](const CppTL::ConstString& key) {
   return resolveReference(key.c_str(), key.end_c_str());
 }
 Value const& Value::operator[](CppTL::ConstString const& key) const
 {
   Value const* found = find(key.c_str(), key.end_c_str());
-  if (!found)
-    return nullSingleton();
+  if (!found) return nullSingleton();
   return *found;
 }
 #endif
 
-Value& Value::append(const Value& value)
-{
-  return (*this)[this->size()] = value;
-}
+Value& Value::append(const Value& value) { return (*this)[size()] = value; }
 
 #if JSON_HAS_RVALUE_REFERENCES
-Value& Value::append(Value&& value)
-{
-  return (*this)[this->size()] = value;
-}
+  Value& Value::append(Value&& value) { return (*this)[size()] = value; }
 #endif
 
-Value Value::get(char const* key, char const* cend,
-                 Value const& defaultValue) const
+Value Value::get(char const* key, char const* cend, Value const& defaultValue) const
 {
-  Value const* found = this->find(key, cend);
+  Value const* found = find(key, cend);
   return !found ? defaultValue : *found;
 }
 Value Value::get(char const* key, Value const& defaultValue) const
 {
-  return this->get(key, key + strlen(key), defaultValue);
+  return get(key, key + strlen(key), defaultValue);
 }
 Value Value::get(JSONCPP_STRING const& key, Value const& defaultValue) const
 {
-  return this->get(key.data(), key.data() + key.length(), defaultValue);
+  return get(key.data(), key.data() + key.length(), defaultValue);
 }
 
+
 bool Value::removeMember(const char* key, const char* cend, Value* removed)
 {
-  if (this->type_ != objectValue) {
+  if (type_ != objectValue) {
     return false;
   }
-  CZString actualKey(key, static_cast<unsigned>(cend - key),
-                     CZString::noDuplication);
-  ObjectValues::iterator it = this->value_.map_->find(actualKey);
-  if (it == this->value_.map_->end())
+  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
+  ObjectValues::iterator it = value_.map_->find(actualKey);
+  if (it == value_.map_->end())
     return false;
   *removed = it->second;
-  this->value_.map_->erase(it);
+  value_.map_->erase(it);
   return true;
 }
 bool Value::removeMember(const char* key, Value* removed)
 {
-  return this->removeMember(key, key + strlen(key), removed);
+  return removeMember(key, key + strlen(key), removed);
 }
 bool Value::removeMember(JSONCPP_STRING const& key, Value* removed)
 {
-  return this->removeMember(key.data(), key.data() + key.length(), removed);
+  return removeMember(key.data(), key.data() + key.length(), removed);
 }
 Value Value::removeMember(const char* key)
 {
   JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                       "in Json::Value::removeMember(): requires objectValue");
-  if (this->type_ == nullValue)
+  if (type_ == nullValue)
     return nullSingleton();
 
-  Value removed; // null
-  this->removeMember(key, key + strlen(key), &removed);
+  Value removed;  // null
+  removeMember(key, key + strlen(key), &removed);
   return removed; // still null if removeMember() did nothing
 }
 Value Value::removeMember(const JSONCPP_STRING& key)
 {
-  return this->removeMember(key.c_str());
+  return removeMember(key.c_str());
 }
 
-bool Value::removeIndex(ArrayIndex index, Value* removed)
-{
-  if (this->type_ != arrayValue) {
+bool Value::removeIndex(ArrayIndex index, Value* removed) {
+  if (type_ != arrayValue) {
     return false;
   }
   CZString key(index);
-  ObjectValues::iterator it = this->value_.map_->find(key);
-  if (it == this->value_.map_->end()) {
+  ObjectValues::iterator it = value_.map_->find(key);
+  if (it == value_.map_->end()) {
     return false;
   }
   *removed = it->second;
-  ArrayIndex oldSize = this->size();
+  ArrayIndex oldSize = size();
   // shift left all items left, into the place of the "removed"
-  for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
+  for (ArrayIndex i = index; i < (oldSize - 1); ++i){
     CZString keey(i);
-    (*this->value_.map_)[keey] = (*this)[i + 1];
+    (*value_.map_)[keey] = (*this)[i + 1];
   }
   // erase the last one ("leftover")
   CZString keyLast(oldSize - 1);
-  ObjectValues::iterator itLast = this->value_.map_->find(keyLast);
-  this->value_.map_->erase(itLast);
+  ObjectValues::iterator itLast = value_.map_->find(keyLast);
+  value_.map_->erase(itLast);
   return true;
 }
 
 #ifdef JSON_USE_CPPTL
 Value Value::get(const CppTL::ConstString& key,
-                 const Value& defaultValue) const
-{
+                 const Value& defaultValue) const {
   return get(key.c_str(), key.end_c_str(), defaultValue);
 }
 #endif
 
 bool Value::isMember(char const* key, char const* cend) const
 {
-  Value const* value = this->find(key, cend);
+  Value const* value = find(key, cend);
   return NULL != value;
 }
 bool Value::isMember(char const* key) const
 {
-  return this->isMember(key, key + strlen(key));
+  return isMember(key, key + strlen(key));
 }
 bool Value::isMember(JSONCPP_STRING const& key) const
 {
-  return this->isMember(key.data(), key.data() + key.length());
+  return isMember(key.data(), key.data() + key.length());
 }
 
 #ifdef JSON_USE_CPPTL
-bool Value::isMember(const CppTL::ConstString& key) const
-{
+bool Value::isMember(const CppTL::ConstString& key) const {
   return isMember(key.c_str(), key.end_c_str());
 }
 #endif
 
-Value::Members Value::getMemberNames() const
-{
+Value::Members Value::getMemberNames() const {
   JSON_ASSERT_MESSAGE(
-    type_ == nullValue || type_ == objectValue,
-    "in Json::Value::getMemberNames(), value must be objectValue");
-  if (this->type_ == nullValue)
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::getMemberNames(), value must be objectValue");
+  if (type_ == nullValue)
     return Value::Members();
   Members members;
-  members.reserve(this->value_.map_->size());
-  ObjectValues::const_iterator it = this->value_.map_->begin();
-  ObjectValues::const_iterator itEnd = this->value_.map_->end();
+  members.reserve(value_.map_->size());
+  ObjectValues::const_iterator it = value_.map_->begin();
+  ObjectValues::const_iterator itEnd = value_.map_->end();
   for (; it != itEnd; ++it) {
-    members.push_back(
-      JSONCPP_STRING((*it).first.data(), (*it).first.length()));
+    members.push_back(JSONCPP_STRING((*it).first.data(),
+                                  (*it).first.length()));
   }
   return members;
 }
@@ -1447,8 +1277,8 @@ Value::Members Value::getMemberNames() const
 //   if ( type_ == objectValue )
 //   {
 //      return CppTL::Enum::any(  CppTL::Enum::transform(
-//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>()
-//         ), MemberNamesTransform() ) );
+//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
+//         MemberNamesTransform() ) );
 //   }
 //   return EnumMemberNames();
 //}
@@ -1465,114 +1295,99 @@ Value::Members Value::getMemberNames() const
 //
 //# endif
 
-static bool IsIntegral(double d)
-{
+static bool IsIntegral(double d) {
   double integral_part;
   return modf(d, &integral_part) == 0.0;
 }
 
-bool Value::isNull() const
-{
-  return this->type_ == nullValue;
-}
+bool Value::isNull() const { return type_ == nullValue; }
 
-bool Value::isBool() const
-{
-  return this->type_ == booleanValue;
-}
+bool Value::isBool() const { return type_ == booleanValue; }
 
-bool Value::isInt() const
-{
-  switch (this->type_) {
-    case intValue:
+bool Value::isInt() const {
+  switch (type_) {
+  case intValue:
 #if defined(JSON_HAS_INT64)
-      return this->value_.int_ >= minInt && this->value_.int_ <= maxInt;
+    return value_.int_ >= minInt && value_.int_ <= maxInt;
 #else
-      return true;
+    return true;
 #endif
-    case uintValue:
-      return this->value_.uint_ <= UInt(maxInt);
-    case realValue:
-      return this->value_.real_ >= minInt && this->value_.real_ <= maxInt &&
-        IsIntegral(this->value_.real_);
-    default:
-      break;
+  case uintValue:
+    return value_.uint_ <= UInt(maxInt);
+  case realValue:
+    return value_.real_ >= minInt && value_.real_ <= maxInt &&
+           IsIntegral(value_.real_);
+  default:
+    break;
   }
   return false;
 }
 
-bool Value::isUInt() const
-{
-  switch (this->type_) {
-    case intValue:
+bool Value::isUInt() const {
+  switch (type_) {
+  case intValue:
 #if defined(JSON_HAS_INT64)
-      return this->value_.int_ >= 0 &&
-        LargestUInt(this->value_.int_) <= LargestUInt(maxUInt);
+    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
 #else
-      return value_.int_ >= 0;
+    return value_.int_ >= 0;
 #endif
-    case uintValue:
+  case uintValue:
 #if defined(JSON_HAS_INT64)
-      return this->value_.uint_ <= maxUInt;
+    return value_.uint_ <= maxUInt;
 #else
-      return true;
+    return true;
 #endif
-    case realValue:
-      return this->value_.real_ >= 0 && this->value_.real_ <= maxUInt &&
-        IsIntegral(this->value_.real_);
-    default:
-      break;
+  case realValue:
+    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
+           IsIntegral(value_.real_);
+  default:
+    break;
   }
   return false;
 }
 
-bool Value::isInt64() const
-{
+bool Value::isInt64() const {
 #if defined(JSON_HAS_INT64)
-  switch (this->type_) {
-    case intValue:
-      return true;
-    case uintValue:
-      return this->value_.uint_ <= UInt64(maxInt64);
-    case realValue:
-      // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
-      // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
-      // require the value to be strictly less than the limit.
-      return this->value_.real_ >= double(minInt64) &&
-        this->value_.real_ < double(maxInt64) &&
-        IsIntegral(this->value_.real_);
-    default:
-      break;
+  switch (type_) {
+  case intValue:
+    return true;
+  case uintValue:
+    return value_.uint_ <= UInt64(maxInt64);
+  case realValue:
+    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= double(minInt64) &&
+           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
+  default:
+    break;
   }
 #endif // JSON_HAS_INT64
   return false;
 }
 
-bool Value::isUInt64() const
-{
+bool Value::isUInt64() const {
 #if defined(JSON_HAS_INT64)
-  switch (this->type_) {
-    case intValue:
-      return this->value_.int_ >= 0;
-    case uintValue:
-      return true;
-    case realValue:
-      // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
-      // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
-      // require the value to be strictly less than the limit.
-      return this->value_.real_ >= 0 &&
-        this->value_.real_ < maxUInt64AsDouble &&
-        IsIntegral(this->value_.real_);
-    default:
-      break;
+  switch (type_) {
+  case intValue:
+    return value_.int_ >= 0;
+  case uintValue:
+    return true;
+  case realValue:
+    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
+           IsIntegral(value_.real_);
+  default:
+    break;
   }
 #endif // JSON_HAS_INT64
   return false;
 }
 
-bool Value::isIntegral() const
-{
-  switch (this->type_) {
+bool Value::isIntegral() const {
+  switch (type_) {
     case intValue:
     case uintValue:
       return true;
@@ -1581,12 +1396,9 @@ bool Value::isIntegral() const
       // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
       // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
       // require the value to be strictly less than the limit.
-      return this->value_.real_ >= double(minInt64) &&
-        this->value_.real_ < maxUInt64AsDouble &&
-        IsIntegral(this->value_.real_);
+      return value_.real_ >= double(minInt64) && value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
 #else
-      return value_.real_ >= minInt && value_.real_ <= maxUInt &&
-        IsIntegral(value_.real_);
+      return value_.real_ >= minInt && value_.real_ <= maxUInt && IsIntegral(value_.real_);
 #endif // JSON_HAS_INT64
     default:
       break;
@@ -1594,89 +1406,53 @@ bool Value::isIntegral() const
   return false;
 }
 
-bool Value::isDouble() const
-{
-  return this->type_ == intValue || this->type_ == uintValue ||
-    this->type_ == realValue;
-}
+bool Value::isDouble() const { return type_ == intValue || type_ == uintValue || type_ == realValue; }
 
-bool Value::isNumeric() const
-{
-  return this->isDouble();
-}
+bool Value::isNumeric() const { return isDouble(); }
 
-bool Value::isString() const
-{
-  return this->type_ == stringValue;
-}
+bool Value::isString() const { return type_ == stringValue; }
 
-bool Value::isArray() const
-{
-  return this->type_ == arrayValue;
-}
+bool Value::isArray() const { return type_ == arrayValue; }
 
-bool Value::isObject() const
-{
-  return this->type_ == objectValue;
-}
+bool Value::isObject() const { return type_ == objectValue; }
 
-void Value::setComment(const char* comment, size_t len,
-                       CommentPlacement placement)
-{
-  if (!this->comments_)
-    this->comments_ = new CommentInfo[numberOfCommentPlacement];
-  if ((len > 0) && (comment[len - 1] == '\n')) {
+void Value::setComment(const char* comment, size_t len, CommentPlacement placement) {
+  if (!comments_)
+    comments_ = new CommentInfo[numberOfCommentPlacement];
+  if ((len > 0) && (comment[len-1] == '\n')) {
     // Always discard trailing newline, to aid indentation.
     len -= 1;
   }
-  this->comments_[placement].setComment(comment, len);
+  comments_[placement].setComment(comment, len);
 }
 
-void Value::setComment(const char* comment, CommentPlacement placement)
-{
-  this->setComment(comment, strlen(comment), placement);
+void Value::setComment(const char* comment, CommentPlacement placement) {
+  setComment(comment, strlen(comment), placement);
 }
 
-void Value::setComment(const JSONCPP_STRING& comment,
-                       CommentPlacement placement)
-{
-  this->setComment(comment.c_str(), comment.length(), placement);
+void Value::setComment(const JSONCPP_STRING& comment, CommentPlacement placement) {
+  setComment(comment.c_str(), comment.length(), placement);
 }
 
-bool Value::hasComment(CommentPlacement placement) const
-{
-  return this->comments_ != 0 && this->comments_[placement].comment_ != 0;
+bool Value::hasComment(CommentPlacement placement) const {
+  return comments_ != 0 && comments_[placement].comment_ != 0;
 }
 
-JSONCPP_STRING Value::getComment(CommentPlacement placement) const
-{
-  if (this->hasComment(placement))
-    return this->comments_[placement].comment_;
+JSONCPP_STRING Value::getComment(CommentPlacement placement) const {
+  if (hasComment(placement))
+    return comments_[placement].comment_;
   return "";
 }
 
-void Value::setOffsetStart(ptrdiff_t start)
-{
-  this->start_ = start;
-}
+void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
 
-void Value::setOffsetLimit(ptrdiff_t limit)
-{
-  this->limit_ = limit;
-}
+void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
 
-ptrdiff_t Value::getOffsetStart() const
-{
-  return this->start_;
-}
+ptrdiff_t Value::getOffsetStart() const { return start_; }
 
-ptrdiff_t Value::getOffsetLimit() const
-{
-  return this->limit_;
-}
+ptrdiff_t Value::getOffsetLimit() const { return limit_; }
 
-JSONCPP_STRING Value::toStyledString() const
-{
+JSONCPP_STRING Value::toStyledString() const {
   StreamWriterBuilder builder;
 
   JSONCPP_STRING out = this->hasComment(commentBefore) ? "\n" : "";
@@ -1686,58 +1462,54 @@ JSONCPP_STRING Value::toStyledString() const
   return out;
 }
 
-Value::const_iterator Value::begin() const
-{
-  switch (this->type_) {
-    case arrayValue:
-    case objectValue:
-      if (this->value_.map_)
-        return const_iterator(this->value_.map_->begin());
-      break;
-    default:
-      break;
+Value::const_iterator Value::begin() const {
+  switch (type_) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return const_iterator(value_.map_->begin());
+    break;
+  default:
+    break;
   }
   return const_iterator();
 }
 
-Value::const_iterator Value::end() const
-{
-  switch (this->type_) {
-    case arrayValue:
-    case objectValue:
-      if (this->value_.map_)
-        return const_iterator(this->value_.map_->end());
-      break;
-    default:
-      break;
+Value::const_iterator Value::end() const {
+  switch (type_) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return const_iterator(value_.map_->end());
+    break;
+  default:
+    break;
   }
   return const_iterator();
 }
 
-Value::iterator Value::begin()
-{
-  switch (this->type_) {
-    case arrayValue:
-    case objectValue:
-      if (this->value_.map_)
-        return iterator(this->value_.map_->begin());
-      break;
-    default:
-      break;
+Value::iterator Value::begin() {
+  switch (type_) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return iterator(value_.map_->begin());
+    break;
+  default:
+    break;
   }
   return iterator();
 }
 
-Value::iterator Value::end()
-{
-  switch (this->type_) {
-    case arrayValue:
-    case objectValue:
-      if (this->value_.map_)
-        return iterator(this->value_.map_->end());
-      break;
-    default:
-      break;
+Value::iterator Value::end() {
+  switch (type_) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return iterator(value_.map_->end());
+    break;
+  default:
+    break;
   }
   return iterator();
 }
@@ -1745,41 +1517,26 @@ Value::iterator Value::end()
 // class PathArgument
 // //////////////////////////////////////////////////////////////////
 
-PathArgument::PathArgument()
-  : key_()
-  , index_()
-  , kind_(kindNone)
-{
-}
+PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {}
 
 PathArgument::PathArgument(ArrayIndex index)
-  : key_()
-  , index_(index)
-  , kind_(kindIndex)
-{
-}
+    : key_(), index_(index), kind_(kindIndex) {}
 
 PathArgument::PathArgument(const char* key)
-  : key_(key)
-  , index_()
-  , kind_(kindKey)
-{
-}
+    : key_(key), index_(), kind_(kindKey) {}
 
 PathArgument::PathArgument(const JSONCPP_STRING& key)
-  : key_(key.c_str())
-  , index_()
-  , kind_(kindKey)
-{
-}
+    : key_(key.c_str()), index_(), kind_(kindKey) {}
 
 // class Path
 // //////////////////////////////////////////////////////////////////
 
-Path::Path(const JSONCPP_STRING& path, const PathArgument& a1,
-           const PathArgument& a2, const PathArgument& a3,
-           const PathArgument& a4, const PathArgument& a5)
-{
+Path::Path(const JSONCPP_STRING& path,
+           const PathArgument& a1,
+           const PathArgument& a2,
+           const PathArgument& a3,
+           const PathArgument& a4,
+           const PathArgument& a5) {
   InArgs in;
   in.reserve(5);
   in.push_back(&a1);
@@ -1787,11 +1544,10 @@ Path::Path(const JSONCPP_STRING& path, const PathArgument& a1,
   in.push_back(&a3);
   in.push_back(&a4);
   in.push_back(&a5);
-  this->makePath(path, in);
+  makePath(path, in);
 }
 
-void Path::makePath(const JSONCPP_STRING& path, const InArgs& in)
-{
+void Path::makePath(const JSONCPP_STRING& path, const InArgs& in) {
   const char* current = path.c_str();
   const char* end = current + path.length();
   InArgs::const_iterator itInArg = in.begin();
@@ -1799,17 +1555,17 @@ void Path::makePath(const JSONCPP_STRING& path, const InArgs& in)
     if (*current == '[') {
       ++current;
       if (*current == '%')
-        this->addPathInArg(path, in, itInArg, PathArgument::kindIndex);
+        addPathInArg(path, in, itInArg, PathArgument::kindIndex);
       else {
         ArrayIndex index = 0;
         for (; current != end && *current >= '0' && *current <= '9'; ++current)
           index = index * 10 + ArrayIndex(*current - '0');
-        this->args_.push_back(index);
+        args_.push_back(index);
       }
       if (current == end || *++current != ']')
-        this->invalidPath(path, int(current - path.c_str()));
+        invalidPath(path, int(current - path.c_str()));
     } else if (*current == '%') {
-      this->addPathInArg(path, in, itInArg, PathArgument::kindKey);
+      addPathInArg(path, in, itInArg, PathArgument::kindKey);
       ++current;
     } else if (*current == '.' || *current == ']') {
       ++current;
@@ -1817,34 +1573,31 @@ void Path::makePath(const JSONCPP_STRING& path, const InArgs& in)
       const char* beginName = current;
       while (current != end && !strchr("[.", *current))
         ++current;
-      this->args_.push_back(JSONCPP_STRING(beginName, current));
+      args_.push_back(JSONCPP_STRING(beginName, current));
     }
   }
 }
 
-void Path::addPathInArg(const JSONCPP_STRING& /*path*/, const InArgs& in,
+void Path::addPathInArg(const JSONCPP_STRING& /*path*/,
+                        const InArgs& in,
                         InArgs::const_iterator& itInArg,
-                        PathArgument::Kind kind)
-{
+                        PathArgument::Kind kind) {
   if (itInArg == in.end()) {
     // Error: missing argument %d
   } else if ((*itInArg)->kind_ != kind) {
     // Error: bad argument type
   } else {
-    this->args_.push_back(**itInArg++);
+    args_.push_back(**itInArg++);
   }
 }
 
-void Path::invalidPath(const JSONCPP_STRING& /*path*/, int /*location*/)
-{
+void Path::invalidPath(const JSONCPP_STRING& /*path*/, int /*location*/) {
   // Error: invalid path.
 }
 
-const Value& Path::resolve(const Value& root) const
-{
+const Value& Path::resolve(const Value& root) const {
   const Value* node = &root;
-  for (Args::const_iterator it = this->args_.begin(); it != this->args_.end();
-       ++it) {
+  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
     const PathArgument& arg = *it;
     if (arg.kind_ == PathArgument::kindIndex) {
       if (!node->isArray() || !node->isValidIndex(arg.index_)) {
@@ -1868,11 +1621,9 @@ const Value& Path::resolve(const Value& root) const
   return *node;
 }
 
-Value Path::resolve(const Value& root, const Value& defaultValue) const
-{
+Value Path::resolve(const Value& root, const Value& defaultValue) const {
   const Value* node = &root;
-  for (Args::const_iterator it = this->args_.begin(); it != this->args_.end();
-       ++it) {
+  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
     const PathArgument& arg = *it;
     if (arg.kind_ == PathArgument::kindIndex) {
       if (!node->isArray() || !node->isValidIndex(arg.index_))
@@ -1889,11 +1640,9 @@ Value Path::resolve(const Value& root, const Value& defaultValue) const
   return *node;
 }
 
-Value& Path::make(Value& root) const
-{
+Value& Path::make(Value& root) const {
   Value* node = &root;
-  for (Args::const_iterator it = this->args_.begin(); it != this->args_.end();
-       ++it) {
+  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
     const PathArgument& arg = *it;
     if (arg.kind_ == PathArgument::kindIndex) {
       if (!node->isArray()) {
diff --git a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
index 803cfab..fc86505 100644
--- a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
+++ b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
@@ -1,115 +1,111 @@
 // Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
-// See file LICENSE for detail or copy at
-// http://jsoncpp.sourceforge.net/LICENSE
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-#  include <json/writer.h>
-
-#  include "json_tool.h"
+#include <json/writer.h>
+#include "json_tool.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
-#include <cassert>
-#include <cstdio>
-#include <cstring>
 #include <iomanip>
 #include <memory>
-#include <set>
 #include <sstream>
 #include <utility>
+#include <set>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
 
-#if defined(_MSC_VER) && _MSC_VER >= 1200 &&                                  \
-  _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
-#  include <float.h>
-#  define isfinite _finite
-#elif defined(__sun) && defined(__SVR4) // Solaris
-#  if !defined(isfinite)
-#    include <ieeefp.h>
-#    define isfinite finite
-#  endif
+#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
+#include <float.h>
+#define isfinite _finite
+#elif defined(__sun) && defined(__SVR4) //Solaris
+#if !defined(isfinite)
+#include <ieeefp.h>
+#define isfinite finite
+#endif
 #elif defined(_AIX)
-#  if !defined(isfinite)
-#    include <math.h>
-#    define isfinite finite
-#  endif
+#if !defined(isfinite)
+#include <math.h>
+#define isfinite finite
+#endif
 #elif defined(__hpux)
-#  if !defined(isfinite) && !defined(__GNUC__)
-#    if defined(__ia64) && !defined(finite)
-#      define isfinite(x)                                                     \
-        ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
-#    else
-#      include <math.h>
-#      define isfinite finite
-#    endif
-#  endif
+#if !defined(isfinite) && !defined(__GNUC__)
+#if defined(__ia64) && !defined(finite)
+#define isfinite(x) ((sizeof(x) == sizeof(float) ? \
+                     _Isfinitef(x) : _IsFinite(x)))
 #else
-#  include <cmath>
-#  if !(defined(__QNXNTO__)) // QNX already defines isfinite
-#    define isfinite std::isfinite
-#  endif
+#include <math.h>
+#define isfinite finite
+#endif
+#endif
+#else
+#include <cmath>
+#if !(defined(__QNXNTO__)) // QNX already defines isfinite
+#define isfinite std::isfinite
+#endif
 #endif
 
 #if defined(_MSC_VER)
-#  if !defined(WINCE) && defined(__STDC_SECURE_LIB__) &&                      \
-    _MSC_VER >= 1500 // VC++ 9.0 and above
-#    define snprintf sprintf_s
-#  elif _MSC_VER >= 1900 // VC++ 14.0 and above
-#    define snprintf std::snprintf
-#  else
-#    define snprintf _snprintf
-#  endif
+#if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above
+#define snprintf sprintf_s
+#elif _MSC_VER >= 1900 // VC++ 14.0 and above
+#define snprintf std::snprintf
+#else
+#define snprintf _snprintf
+#endif
 #elif defined(__ANDROID__) || defined(__QNXNTO__)
-#  define snprintf snprintf
+#define snprintf snprintf
 #elif __cplusplus >= 201103L
-#  if !defined(__MINGW32__) && !defined(__CYGWIN__)
-#    define snprintf std::snprintf
-#  endif
+#if !defined(__MINGW32__) && !defined(__CYGWIN__)
+#define snprintf std::snprintf
+#endif
 #endif
 
-#if defined(__BORLANDC__)
-#  include <float.h>
-#  define isfinite _finite
-#  define snprintf _snprintf
+#if defined(__BORLANDC__)  
+#include <float.h>
+#define isfinite _finite
+#define snprintf _snprintf
 #endif
 
 // Solaris
 #if defined(__sun)
-#  include <ieeefp.h>
-#  if !defined(isfinite)
-#    define isfinite finite
-#  endif
+# include <ieeefp.h>
+# if !defined(isfinite)
+#  define isfinite finite
+# endif
 #endif
 
 // AIX
 #if defined(_AIX)
-#  if !defined(isfinite)
-#    define isfinite finite
-#  endif
+# if !defined(isfinite)
+#  define isfinite finite
+# endif
 #endif
 
 // HP-UX
 #if defined(__hpux)
-#  if !defined(isfinite)
-#    if defined(__ia64) && !defined(finite) && !defined(__GNUC__)
-#      define isfinite(x)                                                     \
-        ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _Isfinite(x)))
-#    else
-#      include <math.h>
-#      define isfinite finite
-#    endif
+# if !defined(isfinite)
+#  if defined(__ia64) && !defined(finite) && !defined(__GNUC__)
+#   define isfinite(x) ((sizeof(x) == sizeof(float) ? \
+                        _Isfinitef(x) : _Isfinite(x)))
+#  else
+#   include <math.h>
+#   define isfinite finite
 #  endif
+# endif
 #endif
 
 // Ancient glibc
 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 2
-#  if !defined(isfinite)
-#    define isfinite __finite
-#  endif
+# if !defined(isfinite)
+#  define isfinite __finite
+# endif
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
 // Disable warning about strdup being deprecated.
-#  pragma warning(disable : 4996)
+#pragma warning(disable : 4996)
 #endif
 
 namespace Json {
@@ -117,11 +113,10 @@ namespace Json {
 #if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
 typedef std::unique_ptr<StreamWriter> StreamWriterPtr;
 #else
-typedef std::auto_ptr<StreamWriter> StreamWriterPtr;
+typedef std::auto_ptr<StreamWriter>   StreamWriterPtr;
 #endif
 
-static bool containsControlCharacter(const char* str)
-{
+static bool containsControlCharacter(const char* str) {
   while (*str) {
     if (isControlCharacter(*(str++)))
       return true;
@@ -129,19 +124,17 @@ static bool containsControlCharacter(const char* str)
   return false;
 }
 
-static bool containsControlCharacter0(const char* str, unsigned len)
-{
+static bool containsControlCharacter0(const char* str, unsigned len) {
   char const* end = str + len;
   while (end != str) {
-    if (isControlCharacter(*str) || 0 == *str)
+    if (isControlCharacter(*str) || 0==*str)
       return true;
     ++str;
   }
   return false;
 }
 
-JSONCPP_STRING valueToString(LargestInt value)
-{
+JSONCPP_STRING valueToString(LargestInt value) {
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
   if (value == Value::minLargestInt) {
@@ -157,8 +150,7 @@ JSONCPP_STRING valueToString(LargestInt value)
   return current;
 }
 
-JSONCPP_STRING valueToString(LargestUInt value)
-{
+JSONCPP_STRING valueToString(LargestUInt value) {
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
   uintToString(value, current);
@@ -168,22 +160,18 @@ JSONCPP_STRING valueToString(LargestUInt value)
 
 #if defined(JSON_HAS_INT64)
 
-JSONCPP_STRING valueToString(Int value)
-{
+JSONCPP_STRING valueToString(Int value) {
   return valueToString(LargestInt(value));
 }
 
-JSONCPP_STRING valueToString(UInt value)
-{
+JSONCPP_STRING valueToString(UInt value) {
   return valueToString(LargestUInt(value));
 }
 
 #endif // # if defined(JSON_HAS_INT64)
 
 namespace {
-JSONCPP_STRING valueToString(double value, bool useSpecialFloats,
-                             unsigned int precision)
-{
+JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int precision) {
   // Allocate a buffer that is more than large enough to store the 16 digits of
   // precision requested below.
   char buffer[36];
@@ -199,8 +187,7 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats,
     len = snprintf(buffer, sizeof(buffer), formatString, value);
     fixNumericLocale(buffer, buffer + len);
 
-    // try to ensure we preserve the fact that this was given to us as a double
-    // on input
+    // try to ensure we preserve the fact that this was given to us as a double on input
     if (!strchr(buffer, '.') && !strchr(buffer, 'e')) {
       strcat(buffer, ".0");
     }
@@ -208,14 +195,11 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats,
   } else {
     // IEEE standard states that NaN values will not compare to themselves
     if (value != value) {
-      len =
-        snprintf(buffer, sizeof(buffer), useSpecialFloats ? "NaN" : "null");
+      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "NaN" : "null");
     } else if (value < 0) {
-      len = snprintf(buffer, sizeof(buffer),
-                     useSpecialFloats ? "-Infinity" : "-1e+9999");
+      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "-Infinity" : "-1e+9999");
     } else {
-      len = snprintf(buffer, sizeof(buffer),
-                     useSpecialFloats ? "Infinity" : "1e+9999");
+      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "Infinity" : "1e+9999");
     }
   }
   assert(len >= 0);
@@ -223,18 +207,11 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats,
 }
 }
 
-JSONCPP_STRING valueToString(double value)
-{
-  return valueToString(value, false, 17);
-}
+JSONCPP_STRING valueToString(double value) { return valueToString(value, false, 17); }
 
-JSONCPP_STRING valueToString(bool value)
-{
-  return value ? "true" : "false";
-}
+JSONCPP_STRING valueToString(bool value) { return value ? "true" : "false"; }
 
-JSONCPP_STRING valueToQuotedString(const char* value)
-{
+JSONCPP_STRING valueToQuotedString(const char* value) {
   if (value == NULL)
     return "";
   // Not sure how to handle unicode...
@@ -245,50 +222,51 @@ JSONCPP_STRING valueToQuotedString(const char* value)
   // Appending to JSONCPP_STRING is not efficient, but this should be rare.
   // (Note: forward slashes are *not* rare, but I am not escaping them.)
   JSONCPP_STRING::size_type maxsize =
-    strlen(value) * 2 + 3; // allescaped+quotes+NULL
+      strlen(value) * 2 + 3; // allescaped+quotes+NULL
   JSONCPP_STRING result;
   result.reserve(maxsize); // to avoid lots of mallocs
   result += "\"";
   for (const char* c = value; *c != 0; ++c) {
     switch (*c) {
-      case '\"':
-        result += "\\\"";
-        break;
-      case '\\':
-        result += "\\\\";
-        break;
-      case '\b':
-        result += "\\b";
-        break;
-      case '\f':
-        result += "\\f";
-        break;
-      case '\n':
-        result += "\\n";
-        break;
-      case '\r':
-        result += "\\r";
-        break;
-      case '\t':
-        result += "\\t";
-        break;
-      // case '/':
-      // Even though \/ is considered a legal escape in JSON, a bare
-      // slash is also legal, so I see no reason to escape it.
-      // (I hope I am not misunderstanding something.
-      // blep notes: actually escaping \/ may be useful in javascript to avoid
-      // </ sequence. Should add a flag to allow this compatibility mode and
-      // prevent this sequence from occurring.
-      default:
-        if (isControlCharacter(*c)) {
-          JSONCPP_OSTRINGSTREAM oss;
-          oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
-              << std::setw(4) << static_cast<int>(*c);
-          result += oss.str();
-        } else {
-          result += *c;
-        }
-        break;
+    case '\"':
+      result += "\\\"";
+      break;
+    case '\\':
+      result += "\\\\";
+      break;
+    case '\b':
+      result += "\\b";
+      break;
+    case '\f':
+      result += "\\f";
+      break;
+    case '\n':
+      result += "\\n";
+      break;
+    case '\r':
+      result += "\\r";
+      break;
+    case '\t':
+      result += "\\t";
+      break;
+    // case '/':
+    // Even though \/ is considered a legal escape in JSON, a bare
+    // slash is also legal, so I see no reason to escape it.
+    // (I hope I am not misunderstanding something.
+    // blep notes: actually escaping \/ may be useful in javascript to avoid </
+    // sequence.
+    // Should add a flag to allow this compatibility mode and prevent this
+    // sequence from occurring.
+    default:
+      if (isControlCharacter(*c)) {
+        JSONCPP_OSTRINGSTREAM oss;
+        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+            << std::setw(4) << static_cast<int>(*c);
+        result += oss.str();
+      } else {
+        result += *c;
+      }
+      break;
     }
   }
   result += "\"";
@@ -296,8 +274,7 @@ JSONCPP_STRING valueToQuotedString(const char* value)
 }
 
 // https://github.com/upcaste/upcaste/blob/master/src/upcore/src/cstring/strnpbrk.cpp
-static char const* strnpbrk(char const* s, char const* accept, size_t n)
-{
+static char const* strnpbrk(char const* s, char const* accept, size_t n) {
   assert((s || !n) && accept);
 
   char const* const end = s + n;
@@ -311,8 +288,7 @@ static char const* strnpbrk(char const* s, char const* accept, size_t n)
   }
   return NULL;
 }
-static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length)
-{
+static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length) {
   if (value == NULL)
     return "";
   // Not sure how to handle unicode...
@@ -322,51 +298,53 @@ static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length)
   // We have to walk value and escape any special characters.
   // Appending to JSONCPP_STRING is not efficient, but this should be rare.
   // (Note: forward slashes are *not* rare, but I am not escaping them.)
-  JSONCPP_STRING::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
+  JSONCPP_STRING::size_type maxsize =
+      length * 2 + 3; // allescaped+quotes+NULL
   JSONCPP_STRING result;
   result.reserve(maxsize); // to avoid lots of mallocs
   result += "\"";
   char const* end = value + length;
   for (const char* c = value; c != end; ++c) {
     switch (*c) {
-      case '\"':
-        result += "\\\"";
-        break;
-      case '\\':
-        result += "\\\\";
-        break;
-      case '\b':
-        result += "\\b";
-        break;
-      case '\f':
-        result += "\\f";
-        break;
-      case '\n':
-        result += "\\n";
-        break;
-      case '\r':
-        result += "\\r";
-        break;
-      case '\t':
-        result += "\\t";
-        break;
-      // case '/':
-      // Even though \/ is considered a legal escape in JSON, a bare
-      // slash is also legal, so I see no reason to escape it.
-      // (I hope I am not misunderstanding something.)
-      // blep notes: actually escaping \/ may be useful in javascript to avoid
-      // </ sequence. Should add a flag to allow this compatibility mode and
-      // prevent this sequence from occurring.
-      default:
-        if ((isControlCharacter(*c)) || (*c == 0)) {
-          JSONCPP_OSTRINGSTREAM oss;
-          oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
-              << std::setw(4) << static_cast<int>(*c);
-          result += oss.str();
-        } else {
-          result += *c;
-        }
-        break;
+    case '\"':
+      result += "\\\"";
+      break;
+    case '\\':
+      result += "\\\\";
+      break;
+    case '\b':
+      result += "\\b";
+      break;
+    case '\f':
+      result += "\\f";
+      break;
+    case '\n':
+      result += "\\n";
+      break;
+    case '\r':
+      result += "\\r";
+      break;
+    case '\t':
+      result += "\\t";
+      break;
+    // case '/':
+    // Even though \/ is considered a legal escape in JSON, a bare
+    // slash is also legal, so I see no reason to escape it.
+    // (I hope I am not misunderstanding something.)
+    // blep notes: actually escaping \/ may be useful in javascript to avoid </
+    // sequence.
+    // Should add a flag to allow this compatibility mode and prevent this
+    // sequence from occurring.
+    default:
+      if ((isControlCharacter(*c)) || (*c == 0)) {
+        JSONCPP_OSTRINGSTREAM oss;
+        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+            << std::setw(4) << static_cast<int>(*c);
+        result += oss.str();
+      } else {
+        result += *c;
+      }
+      break;
     }
   }
   result += "\"";
@@ -375,98 +353,80 @@ static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length)
 
 // Class Writer
 // //////////////////////////////////////////////////////////////////
-Writer::~Writer()
-{
-}
+Writer::~Writer() {}
 
 // Class FastWriter
 // //////////////////////////////////////////////////////////////////
 
 FastWriter::FastWriter()
-  : yamlCompatiblityEnabled_(false)
-  , dropNullPlaceholders_(false)
-  , omitEndingLineFeed_(false)
-{
-}
+    : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
+      omitEndingLineFeed_(false) {}
 
-void FastWriter::enableYAMLCompatibility()
-{
-  this->yamlCompatiblityEnabled_ = true;
-}
+void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
 
-void FastWriter::dropNullPlaceholders()
-{
-  this->dropNullPlaceholders_ = true;
-}
+void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
 
-void FastWriter::omitEndingLineFeed()
-{
-  this->omitEndingLineFeed_ = true;
-}
+void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
 
-JSONCPP_STRING FastWriter::write(const Value& root)
-{
-  this->document_.clear();
-  this->writeValue(root);
-  if (!this->omitEndingLineFeed_)
-    this->document_ += "\n";
-  return this->document_;
+JSONCPP_STRING FastWriter::write(const Value& root) {
+  document_.clear();
+  writeValue(root);
+  if (!omitEndingLineFeed_)
+    document_ += "\n";
+  return document_;
 }
 
-void FastWriter::writeValue(const Value& value)
-{
+void FastWriter::writeValue(const Value& value) {
   switch (value.type()) {
-    case nullValue:
-      if (!this->dropNullPlaceholders_)
-        this->document_ += "null";
-      break;
-    case intValue:
-      this->document_ += valueToString(value.asLargestInt());
-      break;
-    case uintValue:
-      this->document_ += valueToString(value.asLargestUInt());
-      break;
-    case realValue:
-      this->document_ += valueToString(value.asDouble());
-      break;
-    case stringValue: {
-      // Is NULL possible for value.string_? No.
-      char const* str;
-      char const* end;
-      bool ok = value.getString(&str, &end);
-      if (ok)
-        this->document_ +=
-          valueToQuotedStringN(str, static_cast<unsigned>(end - str));
-      break;
+  case nullValue:
+    if (!dropNullPlaceholders_)
+      document_ += "null";
+    break;
+  case intValue:
+    document_ += valueToString(value.asLargestInt());
+    break;
+  case uintValue:
+    document_ += valueToString(value.asLargestUInt());
+    break;
+  case realValue:
+    document_ += valueToString(value.asDouble());
+    break;
+  case stringValue:
+  {
+    // Is NULL possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok) document_ += valueToQuotedStringN(str, static_cast<unsigned>(end-str));
+    break;
+  }
+  case booleanValue:
+    document_ += valueToString(value.asBool());
+    break;
+  case arrayValue: {
+    document_ += '[';
+    ArrayIndex size = value.size();
+    for (ArrayIndex index = 0; index < size; ++index) {
+      if (index > 0)
+        document_ += ',';
+      writeValue(value[index]);
     }
-    case booleanValue:
-      this->document_ += valueToString(value.asBool());
-      break;
-    case arrayValue: {
-      this->document_ += '[';
-      ArrayIndex size = value.size();
-      for (ArrayIndex index = 0; index < size; ++index) {
-        if (index > 0)
-          this->document_ += ',';
-        this->writeValue(value[index]);
-      }
-      this->document_ += ']';
-    } break;
-    case objectValue: {
-      Value::Members members(value.getMemberNames());
-      this->document_ += '{';
-      for (Value::Members::iterator it = members.begin(); it != members.end();
-           ++it) {
-        const JSONCPP_STRING& name = *it;
-        if (it != members.begin())
-          this->document_ += ',';
-        this->document_ += valueToQuotedStringN(
-          name.data(), static_cast<unsigned>(name.length()));
-        this->document_ += this->yamlCompatiblityEnabled_ ? ": " : ":";
-        this->writeValue(value[name]);
-      }
-      this->document_ += '}';
-    } break;
+    document_ += ']';
+  } break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    document_ += '{';
+    for (Value::Members::iterator it = members.begin(); it != members.end();
+         ++it) {
+      const JSONCPP_STRING& name = *it;
+      if (it != members.begin())
+        document_ += ',';
+      document_ += valueToQuotedStringN(name.data(), static_cast<unsigned>(name.length()));
+      document_ += yamlCompatiblityEnabled_ ? ": " : ":";
+      writeValue(value[name]);
+    }
+    document_ += '}';
+  } break;
   }
 }
 
@@ -474,498 +434,454 @@ void FastWriter::writeValue(const Value& value)
 // //////////////////////////////////////////////////////////////////
 
 StyledWriter::StyledWriter()
-  : rightMargin_(74)
-  , indentSize_(3)
-  , addChildValues_()
-{
-}
+    : rightMargin_(74), indentSize_(3), addChildValues_() {}
 
-JSONCPP_STRING StyledWriter::write(const Value& root)
-{
-  this->document_.clear();
-  this->addChildValues_ = false;
-  this->indentString_.clear();
-  this->writeCommentBeforeValue(root);
-  this->writeValue(root);
-  this->writeCommentAfterValueOnSameLine(root);
-  this->document_ += "\n";
-  return this->document_;
+JSONCPP_STRING StyledWriter::write(const Value& root) {
+  document_.clear();
+  addChildValues_ = false;
+  indentString_.clear();
+  writeCommentBeforeValue(root);
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  document_ += "\n";
+  return document_;
 }
 
-void StyledWriter::writeValue(const Value& value)
-{
+void StyledWriter::writeValue(const Value& value) {
   switch (value.type()) {
-    case nullValue:
-      this->pushValue("null");
-      break;
-    case intValue:
-      this->pushValue(valueToString(value.asLargestInt()));
-      break;
-    case uintValue:
-      this->pushValue(valueToString(value.asLargestUInt()));
-      break;
-    case realValue:
-      this->pushValue(valueToString(value.asDouble()));
-      break;
-    case stringValue: {
-      // Is NULL possible for value.string_? No.
-      char const* str;
-      char const* end;
-      bool ok = value.getString(&str, &end);
-      if (ok)
-        this->pushValue(
-          valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
-      else
-        this->pushValue("");
-      break;
-    }
-    case booleanValue:
-      this->pushValue(valueToString(value.asBool()));
-      break;
-    case arrayValue:
-      this->writeArrayValue(value);
-      break;
-    case objectValue: {
-      Value::Members members(value.getMemberNames());
-      if (members.empty())
-        this->pushValue("{}");
-      else {
-        this->writeWithIndent("{");
-        this->indent();
-        Value::Members::iterator it = members.begin();
-        for (;;) {
-          const JSONCPP_STRING& name = *it;
-          const Value& childValue = value[name];
-          this->writeCommentBeforeValue(childValue);
-          this->writeWithIndent(valueToQuotedString(name.c_str()));
-          this->document_ += " : ";
-          this->writeValue(childValue);
-          if (++it == members.end()) {
-            this->writeCommentAfterValueOnSameLine(childValue);
-            break;
-          }
-          this->document_ += ',';
-          this->writeCommentAfterValueOnSameLine(childValue);
+  case nullValue:
+    pushValue("null");
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble()));
+    break;
+  case stringValue:
+  {
+    // Is NULL possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
+    else pushValue("");
+    break;
+  }
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      Value::Members::iterator it = members.begin();
+      for (;;) {
+        const JSONCPP_STRING& name = *it;
+        const Value& childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedString(name.c_str()));
+        document_ += " : ";
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
         }
-        this->unindent();
-        this->writeWithIndent("}");
+        document_ += ',';
+        writeCommentAfterValueOnSameLine(childValue);
       }
-    } break;
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
   }
 }
 
-void StyledWriter::writeArrayValue(const Value& value)
-{
+void StyledWriter::writeArrayValue(const Value& value) {
   unsigned size = value.size();
   if (size == 0)
-    this->pushValue("[]");
+    pushValue("[]");
   else {
-    bool isArrayMultiLine = this->isMultineArray(value);
+    bool isArrayMultiLine = isMultineArray(value);
     if (isArrayMultiLine) {
-      this->writeWithIndent("[");
-      this->indent();
-      bool hasChildValue = !this->childValues_.empty();
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
       unsigned index = 0;
       for (;;) {
         const Value& childValue = value[index];
-        this->writeCommentBeforeValue(childValue);
+        writeCommentBeforeValue(childValue);
         if (hasChildValue)
-          this->writeWithIndent(this->childValues_[index]);
+          writeWithIndent(childValues_[index]);
         else {
-          this->writeIndent();
-          this->writeValue(childValue);
+          writeIndent();
+          writeValue(childValue);
         }
         if (++index == size) {
-          this->writeCommentAfterValueOnSameLine(childValue);
+          writeCommentAfterValueOnSameLine(childValue);
           break;
         }
-        this->document_ += ',';
-        this->writeCommentAfterValueOnSameLine(childValue);
+        document_ += ',';
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      this->unindent();
-      this->writeWithIndent("]");
+      unindent();
+      writeWithIndent("]");
     } else // output on a single line
     {
-      assert(this->childValues_.size() == size);
-      this->document_ += "[ ";
+      assert(childValues_.size() == size);
+      document_ += "[ ";
       for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
-          this->document_ += ", ";
-        this->document_ += this->childValues_[index];
+          document_ += ", ";
+        document_ += childValues_[index];
       }
-      this->document_ += " ]";
+      document_ += " ]";
     }
   }
 }
 
-bool StyledWriter::isMultineArray(const Value& value)
-{
+bool StyledWriter::isMultineArray(const Value& value) {
   ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= this->rightMargin_;
-  this->childValues_.clear();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
   for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
     const Value& childValue = value[index];
     isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                   childValue.size() > 0);
+                        childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
   {
-    this->childValues_.reserve(size);
-    this->addChildValues_ = true;
+    childValues_.reserve(size);
+    addChildValues_ = true;
     ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
     for (ArrayIndex index = 0; index < size; ++index) {
-      if (this->hasCommentForValue(value[index])) {
+      if (hasCommentForValue(value[index])) {
         isMultiLine = true;
       }
-      this->writeValue(value[index]);
-      lineLength +=
-        static_cast<ArrayIndex>(this->childValues_[index].length());
+      writeValue(value[index]);
+      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
     }
-    this->addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= this->rightMargin_;
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
   }
   return isMultiLine;
 }
 
-void StyledWriter::pushValue(const JSONCPP_STRING& value)
-{
-  if (this->addChildValues_)
-    this->childValues_.push_back(value);
+void StyledWriter::pushValue(const JSONCPP_STRING& value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
   else
-    this->document_ += value;
+    document_ += value;
 }
 
-void StyledWriter::writeIndent()
-{
-  if (!this->document_.empty()) {
-    char last = this->document_[this->document_.length() - 1];
+void StyledWriter::writeIndent() {
+  if (!document_.empty()) {
+    char last = document_[document_.length() - 1];
     if (last == ' ') // already indented
       return;
     if (last != '\n') // Comments may add new-line
-      this->document_ += '\n';
+      document_ += '\n';
   }
-  this->document_ += this->indentString_;
+  document_ += indentString_;
 }
 
-void StyledWriter::writeWithIndent(const JSONCPP_STRING& value)
-{
-  this->writeIndent();
-  this->document_ += value;
+void StyledWriter::writeWithIndent(const JSONCPP_STRING& value) {
+  writeIndent();
+  document_ += value;
 }
 
-void StyledWriter::indent()
-{
-  this->indentString_ += JSONCPP_STRING(this->indentSize_, ' ');
-}
+void StyledWriter::indent() { indentString_ += JSONCPP_STRING(indentSize_, ' '); }
 
-void StyledWriter::unindent()
-{
-  assert(this->indentString_.size() >= this->indentSize_);
-  this->indentString_.resize(this->indentString_.size() - this->indentSize_);
+void StyledWriter::unindent() {
+  assert(indentString_.size() >= indentSize_);
+  indentString_.resize(indentString_.size() - indentSize_);
 }
 
-void StyledWriter::writeCommentBeforeValue(const Value& root)
-{
+void StyledWriter::writeCommentBeforeValue(const Value& root) {
   if (!root.hasComment(commentBefore))
     return;
 
-  this->document_ += "\n";
-  this->writeIndent();
+  document_ += "\n";
+  writeIndent();
   const JSONCPP_STRING& comment = root.getComment(commentBefore);
   JSONCPP_STRING::const_iterator iter = comment.begin();
   while (iter != comment.end()) {
-    this->document_ += *iter;
-    if (*iter == '\n' && (iter != comment.end() && *(iter + 1) == '/'))
-      this->writeIndent();
+    document_ += *iter;
+    if (*iter == '\n' &&
+       (iter != comment.end() && *(iter + 1) == '/'))
+      writeIndent();
     ++iter;
   }
 
   // Comments are stripped of trailing newlines, so add one here
-  this->document_ += "\n";
+  document_ += "\n";
 }
 
-void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root)
-{
+void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
   if (root.hasComment(commentAfterOnSameLine))
-    this->document_ += " " + root.getComment(commentAfterOnSameLine);
+    document_ += " " + root.getComment(commentAfterOnSameLine);
 
   if (root.hasComment(commentAfter)) {
-    this->document_ += "\n";
-    this->document_ += root.getComment(commentAfter);
-    this->document_ += "\n";
+    document_ += "\n";
+    document_ += root.getComment(commentAfter);
+    document_ += "\n";
   }
 }
 
-bool StyledWriter::hasCommentForValue(const Value& value)
-{
+bool StyledWriter::hasCommentForValue(const Value& value) {
   return value.hasComment(commentBefore) ||
-    value.hasComment(commentAfterOnSameLine) || value.hasComment(commentAfter);
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
 }
 
 // Class StyledStreamWriter
 // //////////////////////////////////////////////////////////////////
 
 StyledStreamWriter::StyledStreamWriter(JSONCPP_STRING indentation)
-  : document_(NULL)
-  , rightMargin_(74)
-  , indentation_(indentation)
-  , addChildValues_()
-{
-}
-
-void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root)
-{
-  this->document_ = &out;
-  this->addChildValues_ = false;
-  this->indentString_.clear();
-  this->indented_ = true;
-  this->writeCommentBeforeValue(root);
-  if (!this->indented_)
-    this->writeIndent();
-  this->indented_ = true;
-  this->writeValue(root);
-  this->writeCommentAfterValueOnSameLine(root);
-  *this->document_ << "\n";
-  this->document_ = NULL; // Forget the stream, for safety.
-}
-
-void StyledStreamWriter::writeValue(const Value& value)
-{
+    : document_(NULL), rightMargin_(74), indentation_(indentation),
+      addChildValues_() {}
+
+void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root) {
+  document_ = &out;
+  addChildValues_ = false;
+  indentString_.clear();
+  indented_ = true;
+  writeCommentBeforeValue(root);
+  if (!indented_) writeIndent();
+  indented_ = true;
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  *document_ << "\n";
+  document_ = NULL; // Forget the stream, for safety.
+}
+
+void StyledStreamWriter::writeValue(const Value& value) {
   switch (value.type()) {
-    case nullValue:
-      this->pushValue("null");
-      break;
-    case intValue:
-      this->pushValue(valueToString(value.asLargestInt()));
-      break;
-    case uintValue:
-      this->pushValue(valueToString(value.asLargestUInt()));
-      break;
-    case realValue:
-      this->pushValue(valueToString(value.asDouble()));
-      break;
-    case stringValue: {
-      // Is NULL possible for value.string_? No.
-      char const* str;
-      char const* end;
-      bool ok = value.getString(&str, &end);
-      if (ok)
-        this->pushValue(
-          valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
-      else
-        this->pushValue("");
-      break;
-    }
-    case booleanValue:
-      this->pushValue(valueToString(value.asBool()));
-      break;
-    case arrayValue:
-      this->writeArrayValue(value);
-      break;
-    case objectValue: {
-      Value::Members members(value.getMemberNames());
-      if (members.empty())
-        this->pushValue("{}");
-      else {
-        this->writeWithIndent("{");
-        this->indent();
-        Value::Members::iterator it = members.begin();
-        for (;;) {
-          const JSONCPP_STRING& name = *it;
-          const Value& childValue = value[name];
-          this->writeCommentBeforeValue(childValue);
-          this->writeWithIndent(valueToQuotedString(name.c_str()));
-          *this->document_ << " : ";
-          this->writeValue(childValue);
-          if (++it == members.end()) {
-            this->writeCommentAfterValueOnSameLine(childValue);
-            break;
-          }
-          *this->document_ << ",";
-          this->writeCommentAfterValueOnSameLine(childValue);
+  case nullValue:
+    pushValue("null");
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble()));
+    break;
+  case stringValue:
+  {
+    // Is NULL possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
+    else pushValue("");
+    break;
+  }
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      Value::Members::iterator it = members.begin();
+      for (;;) {
+        const JSONCPP_STRING& name = *it;
+        const Value& childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedString(name.c_str()));
+        *document_ << " : ";
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
         }
-        this->unindent();
-        this->writeWithIndent("}");
+        *document_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-    } break;
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
   }
 }
 
-void StyledStreamWriter::writeArrayValue(const Value& value)
-{
+void StyledStreamWriter::writeArrayValue(const Value& value) {
   unsigned size = value.size();
   if (size == 0)
-    this->pushValue("[]");
+    pushValue("[]");
   else {
-    bool isArrayMultiLine = this->isMultineArray(value);
+    bool isArrayMultiLine = isMultineArray(value);
     if (isArrayMultiLine) {
-      this->writeWithIndent("[");
-      this->indent();
-      bool hasChildValue = !this->childValues_.empty();
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
       unsigned index = 0;
       for (;;) {
         const Value& childValue = value[index];
-        this->writeCommentBeforeValue(childValue);
+        writeCommentBeforeValue(childValue);
         if (hasChildValue)
-          this->writeWithIndent(this->childValues_[index]);
+          writeWithIndent(childValues_[index]);
         else {
-          if (!this->indented_)
-            this->writeIndent();
-          this->indented_ = true;
-          this->writeValue(childValue);
-          this->indented_ = false;
+          if (!indented_) writeIndent();
+          indented_ = true;
+          writeValue(childValue);
+          indented_ = false;
         }
         if (++index == size) {
-          this->writeCommentAfterValueOnSameLine(childValue);
+          writeCommentAfterValueOnSameLine(childValue);
           break;
         }
-        *this->document_ << ",";
-        this->writeCommentAfterValueOnSameLine(childValue);
+        *document_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      this->unindent();
-      this->writeWithIndent("]");
+      unindent();
+      writeWithIndent("]");
     } else // output on a single line
     {
-      assert(this->childValues_.size() == size);
-      *this->document_ << "[ ";
+      assert(childValues_.size() == size);
+      *document_ << "[ ";
       for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
-          *this->document_ << ", ";
-        *this->document_ << this->childValues_[index];
+          *document_ << ", ";
+        *document_ << childValues_[index];
       }
-      *this->document_ << " ]";
+      *document_ << " ]";
     }
   }
 }
 
-bool StyledStreamWriter::isMultineArray(const Value& value)
-{
+bool StyledStreamWriter::isMultineArray(const Value& value) {
   ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= this->rightMargin_;
-  this->childValues_.clear();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
   for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
     const Value& childValue = value[index];
     isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                   childValue.size() > 0);
+                        childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
   {
-    this->childValues_.reserve(size);
-    this->addChildValues_ = true;
+    childValues_.reserve(size);
+    addChildValues_ = true;
     ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
     for (ArrayIndex index = 0; index < size; ++index) {
-      if (this->hasCommentForValue(value[index])) {
+      if (hasCommentForValue(value[index])) {
         isMultiLine = true;
       }
-      this->writeValue(value[index]);
-      lineLength +=
-        static_cast<ArrayIndex>(this->childValues_[index].length());
+      writeValue(value[index]);
+      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
     }
-    this->addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= this->rightMargin_;
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
   }
   return isMultiLine;
 }
 
-void StyledStreamWriter::pushValue(const JSONCPP_STRING& value)
-{
-  if (this->addChildValues_)
-    this->childValues_.push_back(value);
+void StyledStreamWriter::pushValue(const JSONCPP_STRING& value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
   else
-    *this->document_ << value;
+    *document_ << value;
 }
 
-void StyledStreamWriter::writeIndent()
-{
+void StyledStreamWriter::writeIndent() {
   // blep intended this to look at the so-far-written string
   // to determine whether we are already indented, but
   // with a stream we cannot do that. So we rely on some saved state.
   // The caller checks indented_.
-  *this->document_ << '\n' << this->indentString_;
+  *document_ << '\n' << indentString_;
 }
 
-void StyledStreamWriter::writeWithIndent(const JSONCPP_STRING& value)
-{
-  if (!this->indented_)
-    this->writeIndent();
-  *this->document_ << value;
-  this->indented_ = false;
+void StyledStreamWriter::writeWithIndent(const JSONCPP_STRING& value) {
+  if (!indented_) writeIndent();
+  *document_ << value;
+  indented_ = false;
 }
 
-void StyledStreamWriter::indent()
-{
-  this->indentString_ += this->indentation_;
-}
+void StyledStreamWriter::indent() { indentString_ += indentation_; }
 
-void StyledStreamWriter::unindent()
-{
-  assert(this->indentString_.size() >= this->indentation_.size());
-  this->indentString_.resize(this->indentString_.size() -
-                             this->indentation_.size());
+void StyledStreamWriter::unindent() {
+  assert(indentString_.size() >= indentation_.size());
+  indentString_.resize(indentString_.size() - indentation_.size());
 }
 
-void StyledStreamWriter::writeCommentBeforeValue(const Value& root)
-{
+void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
   if (!root.hasComment(commentBefore))
     return;
 
-  if (!this->indented_)
-    this->writeIndent();
+  if (!indented_) writeIndent();
   const JSONCPP_STRING& comment = root.getComment(commentBefore);
   JSONCPP_STRING::const_iterator iter = comment.begin();
   while (iter != comment.end()) {
-    *this->document_ << *iter;
-    if (*iter == '\n' && (iter != comment.end() && *(iter + 1) == '/'))
+    *document_ << *iter;
+    if (*iter == '\n' &&
+       (iter != comment.end() && *(iter + 1) == '/'))
       // writeIndent();  // would include newline
-      *this->document_ << this->indentString_;
+      *document_ << indentString_;
     ++iter;
   }
-  this->indented_ = false;
+  indented_ = false;
 }
 
-void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root)
-{
+void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
   if (root.hasComment(commentAfterOnSameLine))
-    *this->document_ << ' ' << root.getComment(commentAfterOnSameLine);
+    *document_ << ' ' << root.getComment(commentAfterOnSameLine);
 
   if (root.hasComment(commentAfter)) {
-    this->writeIndent();
-    *this->document_ << root.getComment(commentAfter);
+    writeIndent();
+    *document_ << root.getComment(commentAfter);
   }
-  this->indented_ = false;
+  indented_ = false;
 }
 
-bool StyledStreamWriter::hasCommentForValue(const Value& value)
-{
+bool StyledStreamWriter::hasCommentForValue(const Value& value) {
   return value.hasComment(commentBefore) ||
-    value.hasComment(commentAfterOnSameLine) || value.hasComment(commentAfter);
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
 }
 
 //////////////////////////
 // BuiltStyledStreamWriter
 
 /// Scoped enums are not available until C++11.
-struct CommentStyle
-{
+struct CommentStyle {
   /// Decide whether to write comments.
-  enum Enum
-  {
-    None, ///< Drop all comments.
-    Most, ///< Recover odd behavior of previous versions (not implemented yet).
-    All   ///< Keep all comments.
+  enum Enum {
+    None,  ///< Drop all comments.
+    Most,  ///< Recover odd behavior of previous versions (not implemented yet).
+    All  ///< Keep all comments.
   };
 };
 
 struct BuiltStyledStreamWriter : public StreamWriter
 {
-  BuiltStyledStreamWriter(JSONCPP_STRING const& indentation,
-                          CommentStyle::Enum cs,
-                          JSONCPP_STRING const& colonSymbol,
-                          JSONCPP_STRING const& nullSymbol,
-                          JSONCPP_STRING const& endingLineFeedSymbol,
-                          bool useSpecialFloats, unsigned int precision);
+  BuiltStyledStreamWriter(
+      JSONCPP_STRING const& indentation,
+      CommentStyle::Enum cs,
+      JSONCPP_STRING const& colonSymbol,
+      JSONCPP_STRING const& nullSymbol,
+      JSONCPP_STRING const& endingLineFeedSymbol,
+      bool useSpecialFloats,
+      unsigned int precision);
   int write(Value const& root, JSONCPP_OSTREAM* sout) JSONCPP_OVERRIDE;
-
 private:
   void writeValue(Value const& value);
   void writeArrayValue(Value const& value);
@@ -995,10 +911,13 @@ private:
   unsigned int precision_;
 };
 BuiltStyledStreamWriter::BuiltStyledStreamWriter(
-  JSONCPP_STRING const& indentation, CommentStyle::Enum cs,
-  JSONCPP_STRING const& colonSymbol, JSONCPP_STRING const& nullSymbol,
-  JSONCPP_STRING const& endingLineFeedSymbol, bool useSpecialFloats,
-  unsigned int precision)
+      JSONCPP_STRING const& indentation,
+      CommentStyle::Enum cs,
+      JSONCPP_STRING const& colonSymbol,
+      JSONCPP_STRING const& nullSymbol,
+      JSONCPP_STRING const& endingLineFeedSymbol,
+      bool useSpecialFloats,
+      unsigned int precision)
   : rightMargin_(74)
   , indentation_(indentation)
   , cs_(cs)
@@ -1013,276 +932,247 @@ BuiltStyledStreamWriter::BuiltStyledStreamWriter(
 }
 int BuiltStyledStreamWriter::write(Value const& root, JSONCPP_OSTREAM* sout)
 {
-  this->sout_ = sout;
-  this->addChildValues_ = false;
-  this->indented_ = true;
-  this->indentString_.clear();
-  this->writeCommentBeforeValue(root);
-  if (!this->indented_)
-    this->writeIndent();
-  this->indented_ = true;
-  this->writeValue(root);
-  this->writeCommentAfterValueOnSameLine(root);
-  *this->sout_ << this->endingLineFeedSymbol_;
-  this->sout_ = NULL;
+  sout_ = sout;
+  addChildValues_ = false;
+  indented_ = true;
+  indentString_.clear();
+  writeCommentBeforeValue(root);
+  if (!indented_) writeIndent();
+  indented_ = true;
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  *sout_ << endingLineFeedSymbol_;
+  sout_ = NULL;
   return 0;
 }
-void BuiltStyledStreamWriter::writeValue(Value const& value)
-{
+void BuiltStyledStreamWriter::writeValue(Value const& value) {
   switch (value.type()) {
-    case nullValue:
-      this->pushValue(this->nullSymbol_);
-      break;
-    case intValue:
-      this->pushValue(valueToString(value.asLargestInt()));
-      break;
-    case uintValue:
-      this->pushValue(valueToString(value.asLargestUInt()));
-      break;
-    case realValue:
-      this->pushValue(valueToString(value.asDouble(), this->useSpecialFloats_,
-                                    this->precision_));
-      break;
-    case stringValue: {
-      // Is NULL is possible for value.string_? No.
-      char const* str;
-      char const* end;
-      bool ok = value.getString(&str, &end);
-      if (ok)
-        this->pushValue(
-          valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
-      else
-        this->pushValue("");
-      break;
-    }
-    case booleanValue:
-      this->pushValue(valueToString(value.asBool()));
-      break;
-    case arrayValue:
-      this->writeArrayValue(value);
-      break;
-    case objectValue: {
-      Value::Members members(value.getMemberNames());
-      if (members.empty())
-        this->pushValue("{}");
-      else {
-        this->writeWithIndent("{");
-        this->indent();
-        Value::Members::iterator it = members.begin();
-        for (;;) {
-          JSONCPP_STRING const& name = *it;
-          Value const& childValue = value[name];
-          this->writeCommentBeforeValue(childValue);
-          this->writeWithIndent(valueToQuotedStringN(
-            name.data(), static_cast<unsigned>(name.length())));
-          *this->sout_ << this->colonSymbol_;
-          this->writeValue(childValue);
-          if (++it == members.end()) {
-            this->writeCommentAfterValueOnSameLine(childValue);
-            break;
-          }
-          *this->sout_ << ",";
-          this->writeCommentAfterValueOnSameLine(childValue);
+  case nullValue:
+    pushValue(nullSymbol_);
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_));
+    break;
+  case stringValue:
+  {
+    // Is NULL is possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
+    else pushValue("");
+    break;
+  }
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      Value::Members::iterator it = members.begin();
+      for (;;) {
+        JSONCPP_STRING const& name = *it;
+        Value const& childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedStringN(name.data(), static_cast<unsigned>(name.length())));
+        *sout_ << colonSymbol_;
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
         }
-        this->unindent();
-        this->writeWithIndent("}");
+        *sout_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-    } break;
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
   }
 }
 
-void BuiltStyledStreamWriter::writeArrayValue(Value const& value)
-{
+void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
   unsigned size = value.size();
   if (size == 0)
-    this->pushValue("[]");
+    pushValue("[]");
   else {
-    bool isMultiLine =
-      (this->cs_ == CommentStyle::All) || this->isMultineArray(value);
+    bool isMultiLine = (cs_ == CommentStyle::All) || isMultineArray(value);
     if (isMultiLine) {
-      this->writeWithIndent("[");
-      this->indent();
-      bool hasChildValue = !this->childValues_.empty();
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
       unsigned index = 0;
       for (;;) {
         Value const& childValue = value[index];
-        this->writeCommentBeforeValue(childValue);
+        writeCommentBeforeValue(childValue);
         if (hasChildValue)
-          this->writeWithIndent(this->childValues_[index]);
+          writeWithIndent(childValues_[index]);
         else {
-          if (!this->indented_)
-            this->writeIndent();
-          this->indented_ = true;
-          this->writeValue(childValue);
-          this->indented_ = false;
+          if (!indented_) writeIndent();
+          indented_ = true;
+          writeValue(childValue);
+          indented_ = false;
         }
         if (++index == size) {
-          this->writeCommentAfterValueOnSameLine(childValue);
+          writeCommentAfterValueOnSameLine(childValue);
           break;
         }
-        *this->sout_ << ",";
-        this->writeCommentAfterValueOnSameLine(childValue);
+        *sout_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      this->unindent();
-      this->writeWithIndent("]");
+      unindent();
+      writeWithIndent("]");
     } else // output on a single line
     {
-      assert(this->childValues_.size() == size);
-      *this->sout_ << "[";
-      if (!this->indentation_.empty())
-        *this->sout_ << " ";
+      assert(childValues_.size() == size);
+      *sout_ << "[";
+      if (!indentation_.empty()) *sout_ << " ";
       for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
-          *this->sout_ << ((!this->indentation_.empty()) ? ", " : ",");
-        *this->sout_ << this->childValues_[index];
+          *sout_ << ((!indentation_.empty()) ? ", " : ",");
+        *sout_ << childValues_[index];
       }
-      if (!this->indentation_.empty())
-        *this->sout_ << " ";
-      *this->sout_ << "]";
+      if (!indentation_.empty()) *sout_ << " ";
+      *sout_ << "]";
     }
   }
 }
 
-bool BuiltStyledStreamWriter::isMultineArray(Value const& value)
-{
+bool BuiltStyledStreamWriter::isMultineArray(Value const& value) {
   ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= this->rightMargin_;
-  this->childValues_.clear();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
   for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
     Value const& childValue = value[index];
     isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                   childValue.size() > 0);
+                        childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
   {
-    this->childValues_.reserve(size);
-    this->addChildValues_ = true;
+    childValues_.reserve(size);
+    addChildValues_ = true;
     ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
     for (ArrayIndex index = 0; index < size; ++index) {
       if (hasCommentForValue(value[index])) {
         isMultiLine = true;
       }
-      this->writeValue(value[index]);
-      lineLength +=
-        static_cast<ArrayIndex>(this->childValues_[index].length());
+      writeValue(value[index]);
+      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
     }
-    this->addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= this->rightMargin_;
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
   }
   return isMultiLine;
 }
 
-void BuiltStyledStreamWriter::pushValue(JSONCPP_STRING const& value)
-{
-  if (this->addChildValues_)
-    this->childValues_.push_back(value);
+void BuiltStyledStreamWriter::pushValue(JSONCPP_STRING const& value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
   else
-    *this->sout_ << value;
+    *sout_ << value;
 }
 
-void BuiltStyledStreamWriter::writeIndent()
-{
+void BuiltStyledStreamWriter::writeIndent() {
   // blep intended this to look at the so-far-written string
   // to determine whether we are already indented, but
   // with a stream we cannot do that. So we rely on some saved state.
   // The caller checks indented_.
 
-  if (!this->indentation_.empty()) {
+  if (!indentation_.empty()) {
     // In this case, drop newlines too.
-    *this->sout_ << '\n' << this->indentString_;
+    *sout_ << '\n' << indentString_;
   }
 }
 
-void BuiltStyledStreamWriter::writeWithIndent(JSONCPP_STRING const& value)
-{
-  if (!this->indented_)
-    this->writeIndent();
-  *this->sout_ << value;
-  this->indented_ = false;
+void BuiltStyledStreamWriter::writeWithIndent(JSONCPP_STRING const& value) {
+  if (!indented_) writeIndent();
+  *sout_ << value;
+  indented_ = false;
 }
 
-void BuiltStyledStreamWriter::indent()
-{
-  this->indentString_ += this->indentation_;
-}
+void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
 
-void BuiltStyledStreamWriter::unindent()
-{
-  assert(this->indentString_.size() >= this->indentation_.size());
-  this->indentString_.resize(this->indentString_.size() -
-                             this->indentation_.size());
+void BuiltStyledStreamWriter::unindent() {
+  assert(indentString_.size() >= indentation_.size());
+  indentString_.resize(indentString_.size() - indentation_.size());
 }
 
-void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root)
-{
-  if (this->cs_ == CommentStyle::None)
-    return;
+void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
+  if (cs_ == CommentStyle::None) return;
   if (!root.hasComment(commentBefore))
     return;
 
-  if (!this->indented_)
-    this->writeIndent();
+  if (!indented_) writeIndent();
   const JSONCPP_STRING& comment = root.getComment(commentBefore);
   JSONCPP_STRING::const_iterator iter = comment.begin();
   while (iter != comment.end()) {
-    *this->sout_ << *iter;
-    if (*iter == '\n' && (iter != comment.end() && *(iter + 1) == '/'))
+    *sout_ << *iter;
+    if (*iter == '\n' &&
+       (iter != comment.end() && *(iter + 1) == '/'))
       // writeIndent();  // would write extra newline
-      *this->sout_ << this->indentString_;
+      *sout_ << indentString_;
     ++iter;
   }
-  this->indented_ = false;
+  indented_ = false;
 }
 
-void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
-  Value const& root)
-{
-  if (this->cs_ == CommentStyle::None)
-    return;
+void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root) {
+  if (cs_ == CommentStyle::None) return;
   if (root.hasComment(commentAfterOnSameLine))
-    *this->sout_ << " " + root.getComment(commentAfterOnSameLine);
+    *sout_ << " " + root.getComment(commentAfterOnSameLine);
 
   if (root.hasComment(commentAfter)) {
-    this->writeIndent();
-    *this->sout_ << root.getComment(commentAfter);
+    writeIndent();
+    *sout_ << root.getComment(commentAfter);
   }
 }
 
 // static
-bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value)
-{
+bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
   return value.hasComment(commentBefore) ||
-    value.hasComment(commentAfterOnSameLine) || value.hasComment(commentAfter);
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
 }
 
 ///////////////
 // StreamWriter
 
 StreamWriter::StreamWriter()
-  : sout_(NULL)
+    : sout_(NULL)
 {
 }
 StreamWriter::~StreamWriter()
 {
 }
 StreamWriter::Factory::~Factory()
-{
-}
+{}
 StreamWriterBuilder::StreamWriterBuilder()
 {
-  setDefaults(&this->settings_);
+  setDefaults(&settings_);
 }
 StreamWriterBuilder::~StreamWriterBuilder()
-{
-}
+{}
 StreamWriter* StreamWriterBuilder::newStreamWriter() const
 {
-  JSONCPP_STRING indentation = this->settings_["indentation"].asString();
-  JSONCPP_STRING cs_str = this->settings_["commentStyle"].asString();
-  bool eyc = this->settings_["enableYAMLCompatibility"].asBool();
-  bool dnp = this->settings_["dropNullPlaceholders"].asBool();
-  bool usf = this->settings_["useSpecialFloats"].asBool();
-  unsigned int pre = this->settings_["precision"].asUInt();
+  JSONCPP_STRING indentation = settings_["indentation"].asString();
+  JSONCPP_STRING cs_str = settings_["commentStyle"].asString();
+  bool eyc = settings_["enableYAMLCompatibility"].asBool();
+  bool dnp = settings_["dropNullPlaceholders"].asBool();
+  bool usf = settings_["useSpecialFloats"].asBool(); 
+  unsigned int pre = settings_["precision"].asUInt();
   CommentStyle::Enum cs = CommentStyle::All;
   if (cs_str == "All") {
     cs = CommentStyle::All;
@@ -1301,11 +1191,11 @@ StreamWriter* StreamWriterBuilder::newStreamWriter() const
   if (dnp) {
     nullSymbol.clear();
   }
-  if (pre > 17)
-    pre = 17;
+  if (pre > 17) pre = 17;
   JSONCPP_STRING endingLineFeedSymbol;
-  return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
-                                     endingLineFeedSymbol, usf, pre);
+  return new BuiltStyledStreamWriter(
+      indentation, cs,
+      colonSymbol, nullSymbol, endingLineFeedSymbol, usf, pre);
 }
 static void getValidWriterKeys(std::set<JSONCPP_STRING>* valid_keys)
 {
@@ -1320,24 +1210,23 @@ static void getValidWriterKeys(std::set<JSONCPP_STRING>* valid_keys)
 bool StreamWriterBuilder::validate(Json::Value* invalid) const
 {
   Json::Value my_invalid;
-  if (!invalid)
-    invalid = &my_invalid; // so we do not need to test for NULL
+  if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
   Json::Value& inv = *invalid;
   std::set<JSONCPP_STRING> valid_keys;
   getValidWriterKeys(&valid_keys);
-  Value::Members keys = this->settings_.getMemberNames();
+  Value::Members keys = settings_.getMemberNames();
   size_t n = keys.size();
   for (size_t i = 0; i < n; ++i) {
     JSONCPP_STRING const& key = keys[i];
     if (valid_keys.find(key) == valid_keys.end()) {
-      inv[key] = this->settings_[key];
+      inv[key] = settings_[key];
     }
   }
   return 0u == inv.size();
 }
 Value& StreamWriterBuilder::operator[](JSONCPP_STRING key)
 {
-  return this->settings_[key];
+  return settings_[key];
 }
 // static
 void StreamWriterBuilder::setDefaults(Json::Value* settings)
@@ -1352,17 +1241,14 @@ void StreamWriterBuilder::setDefaults(Json::Value* settings)
   //! [StreamWriterBuilderDefaults]
 }
 
-JSONCPP_STRING writeString(StreamWriter::Factory const& builder,
-                           Value const& root)
-{
+JSONCPP_STRING writeString(StreamWriter::Factory const& builder, Value const& root) {
   JSONCPP_OSTRINGSTREAM sout;
   StreamWriterPtr const writer(builder.newStreamWriter());
   writer->write(root, &sout);
   return sout.str();
 }
 
-JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root)
-{
+JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root) {
   StreamWriterBuilder builder;
   StreamWriterPtr const writer(builder.newStreamWriter());
   writer->write(root, &sout);