Ran clang-format

robertosfield · robertosfield · commit d7200941e675 · 2025-04-11T10:51:22.000+01:00
diff --git a/include/vsg/io/json.h b/include/vsg/io/json.h
@@ -41,15 +41,15 @@ namespace vsg
 
         inline bool white_space(char c) const
         {
-            return (c==' ' || c=='\t' || c=='\r' || c=='\n');
+            return (c == ' ' || c == '\t' || c == '\r' || c == '\n');
         }
 
         bool read_string(std::string& value);
 
         vsg::ref_ptr<vsg::Object> read_array();
         vsg::ref_ptr<vsg::Object> read_object();
     };
-    VSG_type_name(vsg::JSONParser)
+    VSG_type_name(vsg::JSONParser);
 
     /// json ReaderWriter
     class json : public vsg::Inherit<vsg::ReaderWriter, json>
@@ -67,6 +67,6 @@ namespace vsg
 
         bool getFeatures(Features& features) const override;
     };
-    VSG_type_name(vsg::json)
+    VSG_type_name(vsg::json);
 
-}
+} // namespace vsg
diff --git a/src/vsg/io/json.cpp b/src/vsg/io/json.cpp
@@ -13,8 +13,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <vsg/core/Objects.h>
 #include <vsg/core/Value.h>
 #include <vsg/io/Path.h>
-#include <vsg/io/mem_stream.h>
 #include <vsg/io/json.h>
+#include <vsg/io/mem_stream.h>
 
 #include <fstream>
 
@@ -34,14 +34,14 @@ bool JSONParser::read_string(std::string& value)
     if (buffer[pos] != '"') return false;
 
     // read string
-    auto end_of_value = buffer.find('"', pos+1);
+    auto end_of_value = buffer.find('"', pos + 1);
     if (end_of_value == std::string::npos) return false;
 
     // could have escape characters.
 
-    value = buffer.substr(pos+1, end_of_value-pos-1);
+    value = buffer.substr(pos + 1, end_of_value - pos - 1);
 
-    pos = end_of_value+1;
+    pos = end_of_value + 1;
 
     return true;
 }
@@ -58,7 +58,7 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_array()
 
     // buffer[pos] == '['
     // advance past open bracket
-    pos = buffer.find_first_not_of(" \t\r\n", pos+1);
+    pos = buffer.find_first_not_of(" \t\r\n", pos + 1);
     if (pos == std::string::npos)
     {
         vsg::info(indent, "read_array() contents after [");
@@ -69,7 +69,7 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_array()
 
     auto objects = vsg::Objects::create();
 
-    while(pos != std::string::npos && pos < buffer.size() && buffer[pos] != ']')
+    while (pos != std::string::npos && pos < buffer.size() && buffer[pos] != ']')
     {
         // now look to pair with value after " : "
         if (buffer[pos] == '{')
@@ -95,27 +95,27 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_array()
         }
         else
         {
-            auto end_of_field = buffer.find_first_of(",}]", pos+1);
+            auto end_of_field = buffer.find_first_of(",}]", pos + 1);
             if (end_of_field == std::string::npos) break;
 
             auto end_of_value = end_of_field - 1;
-            while(end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;
+            while (end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;
 
-            if (buffer.compare(pos, end_of_value-pos, "null")==0)
+            if (buffer.compare(pos, end_of_value - pos, "null") == 0)
             {
                 objects->children.push_back(nullptr);
             }
-            else if (buffer.compare(pos, end_of_value-pos, "true")==0)
+            else if (buffer.compare(pos, end_of_value - pos, "true") == 0)
             {
                 objects->children.push_back(vsg::boolValue::create(true));
             }
-            else if (buffer.compare(pos, end_of_value-pos, "false")==0)
+            else if (buffer.compare(pos, end_of_value - pos, "false") == 0)
             {
                 objects->children.push_back(vsg::boolValue::create(false));
             }
             else
             {
-                mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value-pos+1);
+                mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value - pos + 1);
 
                 double value;
                 mstr >> value;
@@ -146,25 +146,24 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()
 
     // buffer[pos] == '{'
     // advance past open bracket
-    pos = buffer.find_first_not_of(" \t\r\n", pos+1);
+    pos = buffer.find_first_not_of(" \t\r\n", pos + 1);
     if (pos == std::string::npos) return {};
 
     indent += 4;
 
-
     auto object = vsg::Object::create();
 
-    while(pos != std::string::npos && pos < buffer.size() && buffer[pos] != '}')
+    while (pos != std::string::npos && pos < buffer.size() && buffer[pos] != '}')
     {
         if (buffer[pos] == '"')
         {
-            auto end_of_string = buffer.find('"', pos+1);
+            auto end_of_string = buffer.find('"', pos + 1);
             if (end_of_string == std::string::npos) break;
 
-            std::string_view name(&buffer[pos+1], end_of_string-pos-1);
+            std::string_view name(&buffer[pos + 1], end_of_string - pos - 1);
 
             // skip white space
-            pos = buffer.find_first_not_of(" \t\r\n", end_of_string+1);
+            pos = buffer.find_first_not_of(" \t\r\n", end_of_string + 1);
             if (pos == std::string::npos)
             {
                 vsg::info(indent, "read_object()  deliminator error end of buffer.");
@@ -174,12 +173,12 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()
             // make sure next charater is the {name : value} deliminator
             if (buffer[pos] != ':')
             {
-                vsg::info(indent, "read_object()  deliminator error buffer[",pos,"] = ", buffer[pos]);
+                vsg::info(indent, "read_object()  deliminator error buffer[", pos, "] = ", buffer[pos]);
                 break;
             }
 
             // skip white space
-            pos = buffer.find_first_not_of(" \t\r\n", pos+1);
+            pos = buffer.find_first_not_of(" \t\r\n", pos + 1);
             if (pos == std::string::npos)
             {
                 break;
@@ -207,28 +206,28 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()
             }
             else
             {
-                auto end_of_field = buffer.find_first_of(",}]", pos+1);
+                auto end_of_field = buffer.find_first_of(",}]", pos + 1);
                 if (end_of_field == std::string::npos) break;
 
                 auto end_of_value = end_of_field - 1;
-                while(end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;
+                while (end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;
 
-                if (buffer.compare(pos, end_of_value-pos, "null")==0)
+                if (buffer.compare(pos, end_of_value - pos, "null") == 0)
                 {
                     // non op?
                     object->setObject(std::string(name), nullptr);
                 }
-                else if (buffer.compare(pos, end_of_value-pos, "true")==0)
+                else if (buffer.compare(pos, end_of_value - pos, "true") == 0)
                 {
                     object->setValue(std::string(name), true);
                 }
-                else if (buffer.compare(pos, end_of_value-pos, "false")==0)
+                else if (buffer.compare(pos, end_of_value - pos, "false") == 0)
                 {
                     object->setValue(std::string(name), false);
                 }
                 else
                 {
-                    mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value-pos+1);
+                    mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value - pos + 1);
 
                     double value;
                     mstr >> value;
@@ -238,7 +237,6 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()
                 // skip to end of field
                 pos = end_of_field;
             }
-
         }
         else if (buffer[pos] == ',')
         {
@@ -280,7 +278,7 @@ vsg::ref_ptr<vsg::Object> json::_read(std::istream& fin, vsg::ref_ptr<const vsg:
     fin.seekg(0, fin.end);
     size_t fileSize = fin.tellg();
 
-    if (fileSize==0) return {};
+    if (fileSize == 0) return {};
 
     JSONParser parser;
 
@@ -295,13 +293,13 @@ vsg::ref_ptr<vsg::Object> json::_read(std::istream& fin, vsg::ref_ptr<const vsg:
     parser.pos = parser.buffer.find_first_not_of(" \t\r\n", 0);
     if (parser.pos == std::string::npos) return {};
 
-    if (parser.buffer[parser.pos]=='{')
+    if (parser.buffer[parser.pos] == '{')
     {
-        result =  parser.read_object();
+        result = parser.read_object();
     }
-    else if (parser.buffer[parser.pos]=='[')
+    else if (parser.buffer[parser.pos] == '[')
     {
-        result =  parser.read_array();
+        result = parser.read_array();
     }
     else
     {
@@ -311,10 +309,9 @@ vsg::ref_ptr<vsg::Object> json::_read(std::istream& fin, vsg::ref_ptr<const vsg:
     return result;
 }
 
-
 vsg::ref_ptr<vsg::Object> json::read(const vsg::Path& filename, vsg::ref_ptr<const vsg::Options> options) const
 {
-    vsg::Path ext  = (options && options->extensionHint) ? options->extensionHint : vsg::lowerCaseFileExtension(filename);
+    vsg::Path ext = (options && options->extensionHint) ? options->extensionHint : vsg::lowerCaseFileExtension(filename);
     if (!supportedExtension(ext)) return {};
 
     vsg::Path filenameToUse = vsg::findFile(filename, options);
@@ -341,7 +338,6 @@ vsg::ref_ptr<vsg::Object> json::read(const uint8_t* ptr, size_t size, vsg::ref_p
     return _read(fin, options);
 }
 
-
 bool json::getFeatures(Features& features) const
 {
     vsg::ReaderWriter::FeatureMask supported_features = static_cast<vsg::ReaderWriter::FeatureMask>(vsg::ReaderWriter::READ_FILENAME | vsg::ReaderWriter::READ_ISTREAM | vsg::ReaderWriter::READ_MEMORY);

Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI`
`13`	`13`	`#include <vsg/core/Objects.h>`
`14`	`14`	`#include <vsg/core/Value.h>`
`15`	`15`	`#include <vsg/io/Path.h>`
`16`		`-#include <vsg/io/mem_stream.h>`
`17`	`16`	`#include <vsg/io/json.h>`
	`17`	`+#include <vsg/io/mem_stream.h>`
`18`	`18`
`19`	`19`	`#include <fstream>`
`20`	`20`
`@@ -34,14 +34,14 @@ bool JSONParser::read_string(std::string& value)`
`34`	`34`	`if (buffer[pos] != '"') return false;`
`35`	`35`
`36`	`36`	`// read string`
`37`		`- auto end_of_value = buffer.find('"', pos+1);`
	`37`	`+ auto end_of_value = buffer.find('"', pos + 1);`
`38`	`38`	`if (end_of_value == std::string::npos) return false;`
`39`	`39`
`40`	`40`	`// could have escape characters.`
`41`	`41`
`42`		`- value = buffer.substr(pos+1, end_of_value-pos-1);`
	`42`	`+ value = buffer.substr(pos + 1, end_of_value - pos - 1);`
`43`	`43`
`44`		`- pos = end_of_value+1;`
	`44`	`+ pos = end_of_value + 1;`
`45`	`45`
`46`	`46`	`return true;`
`47`	`47`	`}`
`@@ -58,7 +58,7 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_array()`
`58`	`58`
`59`	`59`	`// buffer[pos] == '['`
`60`	`60`	`// advance past open bracket`
`61`		`- pos = buffer.find_first_not_of(" \t\r\n", pos+1);`
	`61`	`+ pos = buffer.find_first_not_of(" \t\r\n", pos + 1);`
`62`	`62`	`if (pos == std::string::npos)`
`63`	`63`	`{`
`64`	`64`	`vsg::info(indent, "read_array() contents after [");`
`@@ -69,7 +69,7 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_array()`
`69`	`69`
`70`	`70`	`auto objects = vsg::Objects::create();`
`71`	`71`
`72`		`- while(pos != std::string::npos && pos < buffer.size() && buffer[pos] != ']')`
	`72`	`+ while (pos != std::string::npos && pos < buffer.size() && buffer[pos] != ']')`
`73`	`73`	`{`
`74`	`74`	`// now look to pair with value after " : "`
`75`	`75`	`if (buffer[pos] == '{')`
`@@ -95,27 +95,27 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_array()`
`95`	`95`	`}`
`96`	`96`	`else`
`97`	`97`	`{`
`98`		`- auto end_of_field = buffer.find_first_of(",}]", pos+1);`
	`98`	`+ auto end_of_field = buffer.find_first_of(",}]", pos + 1);`
`99`	`99`	`if (end_of_field == std::string::npos) break;`
`100`	`100`
`101`	`101`	`auto end_of_value = end_of_field - 1;`
`102`		`- while(end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;`
	`102`	`+ while (end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;`
`103`	`103`
`104`		`- if (buffer.compare(pos, end_of_value-pos, "null")==0)`
	`104`	`+ if (buffer.compare(pos, end_of_value - pos, "null") == 0)`
`105`	`105`	`{`
`106`	`106`	`objects->children.push_back(nullptr);`
`107`	`107`	`}`
`108`		`- else if (buffer.compare(pos, end_of_value-pos, "true")==0)`
	`108`	`+ else if (buffer.compare(pos, end_of_value - pos, "true") == 0)`
`109`	`109`	`{`
`110`	`110`	`objects->children.push_back(vsg::boolValue::create(true));`
`111`	`111`	`}`
`112`		`- else if (buffer.compare(pos, end_of_value-pos, "false")==0)`
	`112`	`+ else if (buffer.compare(pos, end_of_value - pos, "false") == 0)`
`113`	`113`	`{`
`114`	`114`	`objects->children.push_back(vsg::boolValue::create(false));`
`115`	`115`	`}`
`116`	`116`	`else`
`117`	`117`	`{`
`118`		`- mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value-pos+1);`
	`118`	`+ mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value - pos + 1);`
`119`	`119`
`120`	`120`	`double value;`
`121`	`121`	`mstr >> value;`
`@@ -146,25 +146,24 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()`
`146`	`146`
`147`	`147`	`// buffer[pos] == '{'`
`148`	`148`	`// advance past open bracket`
`149`		`- pos = buffer.find_first_not_of(" \t\r\n", pos+1);`
	`149`	`+ pos = buffer.find_first_not_of(" \t\r\n", pos + 1);`
`150`	`150`	`if (pos == std::string::npos) return {};`
`151`	`151`
`152`	`152`	`indent += 4;`
`153`	`153`
`154`		`-`
`155`	`154`	`auto object = vsg::Object::create();`
`156`	`155`
`157`		`- while(pos != std::string::npos && pos < buffer.size() && buffer[pos] != '}')`
	`156`	`+ while (pos != std::string::npos && pos < buffer.size() && buffer[pos] != '}')`
`158`	`157`	`{`
`159`	`158`	`if (buffer[pos] == '"')`
`160`	`159`	`{`
`161`		`- auto end_of_string = buffer.find('"', pos+1);`
	`160`	`+ auto end_of_string = buffer.find('"', pos + 1);`
`162`	`161`	`if (end_of_string == std::string::npos) break;`
`163`	`162`
`164`		`- std::string_view name(&buffer[pos+1], end_of_string-pos-1);`
	`163`	`+ std::string_view name(&buffer[pos + 1], end_of_string - pos - 1);`
`165`	`164`
`166`	`165`	`// skip white space`
`167`		`- pos = buffer.find_first_not_of(" \t\r\n", end_of_string+1);`
	`166`	`+ pos = buffer.find_first_not_of(" \t\r\n", end_of_string + 1);`
`168`	`167`	`if (pos == std::string::npos)`
`169`	`168`	`{`
`170`	`169`	`vsg::info(indent, "read_object() deliminator error end of buffer.");`
`@@ -174,12 +173,12 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()`
`174`	`173`	`// make sure next charater is the {name : value} deliminator`
`175`	`174`	`if (buffer[pos] != ':')`
`176`	`175`	`{`
`177`		`- vsg::info(indent, "read_object() deliminator error buffer[",pos,"] = ", buffer[pos]);`
	`176`	`+ vsg::info(indent, "read_object() deliminator error buffer[", pos, "] = ", buffer[pos]);`
`178`	`177`	`break;`
`179`	`178`	`}`
`180`	`179`
`181`	`180`	`// skip white space`
`182`		`- pos = buffer.find_first_not_of(" \t\r\n", pos+1);`
	`181`	`+ pos = buffer.find_first_not_of(" \t\r\n", pos + 1);`
`183`	`182`	`if (pos == std::string::npos)`
`184`	`183`	`{`
`185`	`184`	`break;`
`@@ -207,28 +206,28 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()`
`207`	`206`	`}`
`208`	`207`	`else`
`209`	`208`	`{`
`210`		`- auto end_of_field = buffer.find_first_of(",}]", pos+1);`
	`209`	`+ auto end_of_field = buffer.find_first_of(",}]", pos + 1);`
`211`	`210`	`if (end_of_field == std::string::npos) break;`
`212`	`211`
`213`	`212`	`auto end_of_value = end_of_field - 1;`
`214`		`- while(end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;`
	`213`	`+ while (end_of_value > 0 && white_space(buffer[end_of_value])) --end_of_value;`
`215`	`214`
`216`		`- if (buffer.compare(pos, end_of_value-pos, "null")==0)`
	`215`	`+ if (buffer.compare(pos, end_of_value - pos, "null") == 0)`
`217`	`216`	`{`
`218`	`217`	`// non op?`
`219`	`218`	`object->setObject(std::string(name), nullptr);`
`220`	`219`	`}`
`221`		`- else if (buffer.compare(pos, end_of_value-pos, "true")==0)`
	`220`	`+ else if (buffer.compare(pos, end_of_value - pos, "true") == 0)`
`222`	`221`	`{`
`223`	`222`	`object->setValue(std::string(name), true);`
`224`	`223`	`}`
`225`		`- else if (buffer.compare(pos, end_of_value-pos, "false")==0)`
	`224`	`+ else if (buffer.compare(pos, end_of_value - pos, "false") == 0)`
`226`	`225`	`{`
`227`	`226`	`object->setValue(std::string(name), false);`
`228`	`227`	`}`
`229`	`228`	`else`
`230`	`229`	`{`
`231`		`- mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value-pos+1);`
	`230`	`+ mstr.set(reinterpret_cast<const uint8_t*>(&buffer.at(pos)), end_of_value - pos + 1);`
`232`	`231`
`233`	`232`	`double value;`
`234`	`233`	`mstr >> value;`
`@@ -238,7 +237,6 @@ vsg::ref_ptr<vsg::Object> JSONParser::read_object()`
`238`	`237`	`// skip to end of field`
`239`	`238`	`pos = end_of_field;`
`240`	`239`	`}`
`241`		`-`
`242`	`240`	`}`
`243`	`241`	`else if (buffer[pos] == ',')`
`244`	`242`	`{`
`@@ -280,7 +278,7 @@ vsg::ref_ptr<vsg::Object> json::_read(std::istream& fin, vsg::ref_ptr<const vsg:`
`280`	`278`	`fin.seekg(0, fin.end);`
`281`	`279`	`size_t fileSize = fin.tellg();`
`282`	`280`
`283`		`- if (fileSize==0) return {};`
	`281`	`+ if (fileSize == 0) return {};`
`284`	`282`
`285`	`283`	`JSONParser parser;`
`286`	`284`
`@@ -295,13 +293,13 @@ vsg::ref_ptr<vsg::Object> json::_read(std::istream& fin, vsg::ref_ptr<const vsg:`
`295`	`293`	`parser.pos = parser.buffer.find_first_not_of(" \t\r\n", 0);`
`296`	`294`	`if (parser.pos == std::string::npos) return {};`
`297`	`295`
`298`		`- if (parser.buffer[parser.pos]=='{')`
	`296`	`+ if (parser.buffer[parser.pos] == '{')`
`299`	`297`	`{`
`300`		`- result = parser.read_object();`
	`298`	`+ result = parser.read_object();`
`301`	`299`	`}`
`302`		`- else if (parser.buffer[parser.pos]=='[')`
	`300`	`+ else if (parser.buffer[parser.pos] == '[')`
`303`	`301`	`{`
`304`		`- result = parser.read_array();`
	`302`	`+ result = parser.read_array();`
`305`	`303`	`}`
`306`	`304`	`else`
`307`	`305`	`{`
`@@ -311,10 +309,9 @@ vsg::ref_ptr<vsg::Object> json::_read(std::istream& fin, vsg::ref_ptr<const vsg:`
`311`	`309`	`return result;`
`312`	`310`	`}`
`313`	`311`
`314`		`-`
`315`	`312`	`vsg::ref_ptr<vsg::Object> json::read(const vsg::Path& filename, vsg::ref_ptr<const vsg::Options> options) const`
`316`	`313`	`{`
`317`		`- vsg::Path ext = (options && options->extensionHint) ? options->extensionHint : vsg::lowerCaseFileExtension(filename);`
	`314`	`+ vsg::Path ext = (options && options->extensionHint) ? options->extensionHint : vsg::lowerCaseFileExtension(filename);`
`318`	`315`	`if (!supportedExtension(ext)) return {};`
`319`	`316`
`320`	`317`	`vsg::Path filenameToUse = vsg::findFile(filename, options);`
`@@ -341,7 +338,6 @@ vsg::ref_ptr<vsg::Object> json::read(const uint8_t* ptr, size_t size, vsg::ref_p`
`341`	`338`	`return _read(fin, options);`
`342`	`339`	`}`
`343`	`340`
`344`		`-`
`345`	`341`	`bool json::getFeatures(Features& features) const`
`346`	`342`	`{`
`347`	`343`	`vsg::ReaderWriter::FeatureMask supported_features = static_cast<vsg::ReaderWriter::FeatureMask>(vsg::ReaderWriter::READ_FILENAME \| vsg::ReaderWriter::READ_ISTREAM \| vsg::ReaderWriter::READ_MEMORY);`