Merge branch 'master' into performance-optimization

2025-09-07 20:04:41 -04:00 · 2025-01-10 15:39:13 -08:00 · 2025-01-10 15:39:13 -08:00 · 8b8dc99b77
commit 8b8dc99b77
parent a4cd18ba62 ba004477a6
3 changed files with 272 additions and 7 deletions
--- a/include/json/value.h
+++ b/include/json/value.h
@ -39,6 +39,10 @@
 #endif
 #endif

+#if __cplusplus >= 201703L
+#define JSONCPP_HAS_STRING_VIEW 1
+#endif
+
 #include <array>
 #include <exception>
 #include <map>
@ -46,6 +50,10 @@
 #include <string>
 #include <vector>

+#ifdef JSONCPP_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
 // Disable warning C4251: <data member>: <type> needs to have dll-interface to
 // be used by...
 #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
@ -342,6 +350,9 @@ public:
   */
  Value(const StaticString& value);
  Value(const String& value);
+#ifdef JSONCPP_HAS_STRING_VIEW
+  Value(std::string_view value);
+#endif
  Value(bool value);
  Value(std::nullptr_t ptr) = delete;
  Value(const Value& other);
@ -384,6 +395,12 @@ public:
   *  \return false if !string. (Seg-fault if str or end are NULL.)
   */
  bool getString(char const** begin, char const** end) const;
+#ifdef JSONCPP_HAS_STRING_VIEW
+  /** Get string_view of string-value.
+   *  \return false if !string. (Seg-fault if str is NULL.)
+   */
+  bool getString(std::string_view* str) const;
+#endif
  Int asInt() const;
  UInt asUInt() const;
 #if defined(JSON_HAS_INT64)
@ -470,6 +487,15 @@ public:
  bool insert(ArrayIndex index, const Value& newValue);
  bool insert(ArrayIndex index, Value&& newValue);

+#ifdef JSONCPP_HAS_STRING_VIEW
+  /// Access an object value by name, create a null member if it does not exist.
+  /// \param key may contain embedded nulls.
+  Value& operator[](std::string_view key);
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
+  /// \param key may contain embedded nulls.
+  const Value& operator[](std::string_view key) const;
+#else
  /// Access an object value by name, create a null member if it does not exist.
  /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
  /// Exceeding that will cause an exception.
@ -484,6 +510,7 @@ public:
  /// that name.
  /// \param key may contain embedded nulls.
  const Value& operator[](const String& key) const;
+#endif
  /** \brief Access an object value by name, create a null member if it does not
   * exist.
   *
@ -497,18 +524,24 @@ public:
   *   \endcode
   */
  Value& operator[](const StaticString& key);
+#ifdef JSONCPP_HAS_STRING_VIEW
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  Value get(std::string_view key, const Value& defaultValue) const;
+#else
  /// Return the member named key if it exist, defaultValue otherwise.
  /// \note deep copy
  Value get(const char* key, const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \param key may contain embedded nulls.
+  Value get(const String& key, const Value& defaultValue) const;
+#endif
  /// Return the member named key if it exist, defaultValue otherwise.
  /// \note deep copy
  /// \note key may contain embedded nulls.
  Value get(const char* begin, const char* end,
            const Value& defaultValue) const;
-  /// Return the member named key if it exist, defaultValue otherwise.
-  /// \note deep copy
-  /// \param key may contain embedded nulls.
-  Value get(const String& key, const Value& defaultValue) const;
  /// Most general and efficient version of isMember()const, get()const,
  /// and operator[]const
  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
@ -516,6 +549,29 @@ public:
  /// Most general and efficient version of isMember()const, get()const,
  /// and operator[]const
  Value const* find(const String& key) const;
+
+  /// Calls find and only returns a valid pointer if the type is found
+  template <typename T, bool (T::*TMemFn)() const>
+  Value const* findValue(const String& key) const {
+    Value const* found = find(key);
+    if (!found || !(found->*TMemFn)())
+      return nullptr;
+    return found;
+  }
+
+  Value const* findNull(const String& key) const;
+  Value const* findBool(const String& key) const;
+  Value const* findInt(const String& key) const;
+  Value const* findInt64(const String& key) const;
+  Value const* findUInt(const String& key) const;
+  Value const* findUInt64(const String& key) const;
+  Value const* findIntegral(const String& key) const;
+  Value const* findDouble(const String& key) const;
+  Value const* findNumeric(const String& key) const;
+  Value const* findString(const String& key) const;
+  Value const* findArray(const String& key) const;
+  Value const* findObject(const String& key) const;
+
  /// Most general and efficient version of object-mutators.
  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
  /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
@ -525,20 +581,28 @@ public:
  /// Do nothing if it did not exist.
  /// \pre type() is objectValue or nullValue
  /// \post type() is unchanged
+#if JSONCPP_HAS_STRING_VIEW
+  void removeMember(std::string_view key);
+#else
  void removeMember(const char* key);
  /// Same as removeMember(const char*)
  /// \param key may contain embedded nulls.
  void removeMember(const String& key);
-  /// Same as removeMember(const char* begin, const char* end, Value* removed),
-  /// but 'key' is null-terminated.
-  bool removeMember(const char* key, Value* removed);
+#endif
  /** \brief Remove the named map member.
   *
   *  Update 'removed' iff removed.
   *  \param key may contain embedded nulls.
   *  \return true iff removed (no exceptions)
   */
+#if JSONCPP_HAS_STRING_VIEW
+  bool removeMember(std::string_view key, Value* removed);
+#else
  bool removeMember(String const& key, Value* removed);
+  /// Same as removeMember(const char* begin, const char* end, Value* removed),
+  /// but 'key' is null-terminated.
+  bool removeMember(const char* key, Value* removed);
+#endif
  /// Same as removeMember(String const& key, Value* removed)
  bool removeMember(const char* begin, const char* end, Value* removed);
  /** \brief Remove the indexed array element.
@ -549,12 +613,18 @@ public:
   */
  bool removeIndex(ArrayIndex index, Value* removed);

+#ifdef JSONCPP_HAS_STRING_VIEW
+  /// Return true if the object has a member named key.
+  /// \param key may contain embedded nulls.
+  bool isMember(std::string_view key) const;
+#else
  /// Return true if the object has a member named key.
  /// \note 'key' must be null-terminated.
  bool isMember(const char* key) const;
  /// Return true if the object has a member named key.
  /// \param key may contain embedded nulls.
  bool isMember(const String& key) const;
+#endif
  /// Same as isMember(String const& key)const
  bool isMember(const char* begin, const char* end) const;

--- a/src/lib_json/json_value.cpp
+++ b/src/lib_json/json_value.cpp
@ -17,6 +17,10 @@
 #include <sstream>
 #include <utility>

+#ifdef JSONCPP_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
 // Provide implementation equivalent of std::snprintf for older _MSC compilers
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #include <stdarg.h>
@ -420,6 +424,14 @@ Value::Value(const String& value) {
      value.data(), static_cast<unsigned>(value.length()));
 }

+#ifdef JSONCPP_HAS_STRING_VIEW
+Value::Value(std::string_view value) {
+  initBasic(stringValue, true);
+  value_.string_ = duplicateAndPrefixStringValue(
+      value.data(), static_cast<unsigned>(value.length()));
+}
+#endif
+
 Value::Value(const StaticString& value) {
  initBasic(stringValue);
  value_.string_ = const_cast<char*>(value.c_str());
@ -627,6 +639,21 @@ bool Value::getString(char const** begin, char const** end) const {
  return true;
 }

+#ifdef JSONCPP_HAS_STRING_VIEW
+bool Value::getString(std::string_view* str) const {
+  if (type() != stringValue)
+    return false;
+  if (value_.string_ == nullptr)
+    return false;
+  const char* begin;
+  unsigned length;
+  decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
+                       &begin);
+  *str = std::string_view(begin, length);
+  return true;
+}
+#endif
+
 String Value::asString() const {
  switch (type()) {
  case nullValue:
@ -1102,12 +1129,61 @@ Value const* Value::find(char const* begin, char const* end) const {
 Value const* Value::find(const String& key) const {
  return find(key.data(), key.data() + key.length());
 }
+
+Value const* Value::findNull(const String& key) const {
+  return findValue<Value, &Value::isNull>(key);
+}
+Value const* Value::findBool(const String& key) const {
+  return findValue<Value, &Value::isBool>(key);
+}
+Value const* Value::findInt(const String& key) const {
+  return findValue<Value, &Value::isInt>(key);
+}
+Value const* Value::findInt64(const String& key) const {
+  return findValue<Value, &Value::isInt64>(key);
+}
+Value const* Value::findUInt(const String& key) const {
+  return findValue<Value, &Value::isUInt>(key);
+}
+Value const* Value::findUInt64(const String& key) const {
+  return findValue<Value, &Value::isUInt64>(key);
+}
+Value const* Value::findIntegral(const String& key) const {
+  return findValue<Value, &Value::isIntegral>(key);
+}
+Value const* Value::findDouble(const String& key) const {
+  return findValue<Value, &Value::isDouble>(key);
+}
+Value const* Value::findNumeric(const String& key) const {
+  return findValue<Value, &Value::isNumeric>(key);
+}
+Value const* Value::findString(const String& key) const {
+  return findValue<Value, &Value::isString>(key);
+}
+Value const* Value::findArray(const String& key) const {
+  return findValue<Value, &Value::isArray>(key);
+}
+Value const* Value::findObject(const String& key) const {
+  return findValue<Value, &Value::isObject>(key);
+}
+
 Value* Value::demand(char const* begin, char const* end) {
  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
                      "in Json::Value::demand(begin, end): requires "
                      "objectValue or nullValue");
  return &resolveReference(begin, end);
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+const Value& Value::operator[](std::string_view key) const {
+  Value const* found = find(key.data(), key.data() + key.length());
+  if (!found)
+    return nullSingleton();
+  return *found;
+}
+Value& Value::operator[](std::string_view key) {
+  return resolveReference(key.data(), key.data() + key.length());
+}
+#else
 const Value& Value::operator[](const char* key) const {
  Value const* found = find(key, key + strlen(key));
  if (!found)
@ -1128,6 +1204,7 @@ Value& Value::operator[](const char* key) {
 Value& Value::operator[](const String& key) {
  return resolveReference(key.data(), key.data() + key.length());
 }
+#endif

 Value& Value::operator[](const StaticString& key) {
  return resolveReference(key.c_str());
@ -1167,12 +1244,18 @@ Value Value::get(char const* begin, char const* end,
  Value const* found = find(begin, end);
  return !found ? defaultValue : *found;
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+Value Value::get(std::string_view key, const Value& defaultValue) const {
+  return get(key.data(), key.data() + key.length(), defaultValue);
+}
+#else
 Value Value::get(char const* key, Value const& defaultValue) const {
  return get(key, key + strlen(key), defaultValue);
 }
 Value Value::get(String const& key, Value const& defaultValue) const {
  return get(key.data(), key.data() + key.length(), defaultValue);
 }
+#endif

 bool Value::removeMember(const char* begin, const char* end, Value* removed) {
  if (type() != objectValue) {
@ -1188,12 +1271,31 @@ bool Value::removeMember(const char* begin, const char* end, Value* removed) {
  value_.map_->erase(it);
  return true;
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+bool Value::removeMember(std::string_view key, Value* removed) {
+  return removeMember(key.data(), key.data() + key.length(), removed);
+}
+#else
 bool Value::removeMember(const char* key, Value* removed) {
  return removeMember(key, key + strlen(key), removed);
 }
 bool Value::removeMember(String const& key, Value* removed) {
  return removeMember(key.data(), key.data() + key.length(), removed);
 }
+#endif
+
+#ifdef JSONCPP_HAS_STRING_VIEW
+void Value::removeMember(std::string_view key) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+                      "in Json::Value::removeMember(): requires objectValue");
+  if (type() == nullValue)
+    return;
+
+  CZString actualKey(key.data(), unsigned(key.length()),
+                     CZString::noDuplication);
+  value_.map_->erase(actualKey);
+}
+#else
 void Value::removeMember(const char* key) {
  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
                      "in Json::Value::removeMember(): requires objectValue");
@ -1204,6 +1306,7 @@ void Value::removeMember(const char* key) {
  value_.map_->erase(actualKey);
 }
 void Value::removeMember(const String& key) { removeMember(key.c_str()); }
+#endif

 bool Value::removeIndex(ArrayIndex index, Value* removed) {
  if (type() != arrayValue) {
@ -1233,12 +1336,18 @@ bool Value::isMember(char const* begin, char const* end) const {
  Value const* value = find(begin, end);
  return nullptr != value;
 }
+#ifdef JSONCPP_HAS_STRING_VIEW
+bool Value::isMember(std::string_view key) const {
+  return isMember(key.data(), key.data() + key.length());
+}
+#else
 bool Value::isMember(char const* key) const {
  return isMember(key, key + strlen(key));
 }
 bool Value::isMember(String const& key) const {
  return isMember(key.data(), key.data() + key.length());
 }
+#endif

 Value::Members Value::getMemberNames() const {
  JSON_ASSERT_MESSAGE(
--- a/src/test_lib_json/main.cpp
+++ b/src/test_lib_json/main.cpp
@ -76,6 +76,8 @@ struct ValueTest : JsonTest::TestCase {
  Json::Value float_{0.00390625f};
  Json::Value array1_;
  Json::Value object1_;
+  Json::Value object2_;
+  Json::Value object3_;
  Json::Value emptyString_{""};
  Json::Value string1_{"a"};
  Json::Value string_{"sometext with space"};
@ -85,6 +87,34 @@ struct ValueTest : JsonTest::TestCase {
  ValueTest() {
    array1_.append(1234);
    object1_["id"] = 1234;
+
+    // object2 with matching values
+    object2_["null"] = Json::nullValue;
+    object2_["bool"] = true;
+    object2_["int"] = Json::Int{Json::Value::maxInt};
+    object2_["int64"] = Json::Int64{Json::Value::maxInt64};
+    object2_["uint"] = Json::UInt{Json::Value::maxUInt};
+    object2_["uint64"] = Json::UInt64{Json::Value::maxUInt64};
+    object2_["integral"] = 1234;
+    object2_["double"] = 1234.56789;
+    object2_["numeric"] = 0.12345f;
+    object2_["string"] = "string";
+    object2_["array"] = Json::arrayValue;
+    object2_["object"] = Json::objectValue;
+
+    // object3 with not matching values
+    object3_["object"] = Json::nullValue;
+    object3_["null"] = true;
+    object3_["bool"] = Json::Int{Json::Value::maxInt};
+    object3_["int"] = "not_an_int";
+    object3_["int64"] = "not_an_int64";
+    object3_["uint"] = "not_an_uint";
+    object3_["uin64"] = "not_an_uint64";
+    object3_["integral"] = 1234.56789;
+    object3_["double"] = false;
+    object3_["numeric"] = "string";
+    object3_["string"] = Json::arrayValue;
+    object3_["array"] = Json::objectValue;
  }

  struct IsCheck {
@ -234,6 +264,62 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, objects) {
  const Json::Value* stringFoundUnknownId = object1_.find(stringUnknownIdKey);
  JSONTEST_ASSERT_EQUAL(nullptr, stringFoundUnknownId);

+  // Access through find<Type>()
+  const Json::Value* nullFound = object2_.findNull("null");
+  JSONTEST_ASSERT(nullFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::nullValue, *nullFound);
+  JSONTEST_ASSERT(object3_.findNull("null") == nullptr);
+
+  const Json::Value* boolFound = object2_.findBool("bool");
+  JSONTEST_ASSERT(boolFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(true, *boolFound);
+  JSONTEST_ASSERT(object3_.findBool("bool") == nullptr);
+
+  const Json::Value* intFound = object2_.findInt("int");
+  JSONTEST_ASSERT(intFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::Int{Json::Value::maxInt}, *intFound);
+  JSONTEST_ASSERT(object3_.findInt("int") == nullptr);
+
+  const Json::Value* int64Found = object2_.findInt64("int64");
+  JSONTEST_ASSERT(int64Found != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::Int64{Json::Value::maxInt64}, *int64Found);
+  JSONTEST_ASSERT(object3_.findInt64("int64") == nullptr);
+
+  const Json::Value* uintFound = object2_.findUInt("uint");
+  JSONTEST_ASSERT(uintFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::UInt{Json::Value::maxUInt}, *uintFound);
+  JSONTEST_ASSERT(object3_.findUInt("uint") == nullptr);
+
+  const Json::Value* uint64Found = object2_.findUInt64("uint64");
+  JSONTEST_ASSERT(uint64Found != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::UInt64{Json::Value::maxUInt64}, *uint64Found);
+  JSONTEST_ASSERT(object3_.findUInt64("uint64") == nullptr);
+
+  const Json::Value* integralFound = object2_.findIntegral("integral");
+  JSONTEST_ASSERT(integralFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(1234, *integralFound);
+  JSONTEST_ASSERT(object3_.findIntegral("integral") == nullptr);
+
+  const Json::Value* doubleFound = object2_.findDouble("double");
+  JSONTEST_ASSERT(doubleFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(1234.56789, *doubleFound);
+  JSONTEST_ASSERT(object3_.findDouble("double") == nullptr);
+
+  const Json::Value* numericFound = object2_.findNumeric("numeric");
+  JSONTEST_ASSERT(numericFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(0.12345f, *numericFound);
+  JSONTEST_ASSERT(object3_.findNumeric("numeric") == nullptr);
+
+  const Json::Value* stringFound = object2_.findString("string");
+  JSONTEST_ASSERT(stringFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(std::string{"string"}, *stringFound);
+  JSONTEST_ASSERT(object3_.findString("string") == nullptr);
+
+  const Json::Value* arrayFound = object2_.findArray("array");
+  JSONTEST_ASSERT(arrayFound != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::arrayValue, *arrayFound);
+  JSONTEST_ASSERT(object3_.findArray("array") == nullptr);
+
  // Access through demand()
  const char yetAnotherIdKey[] = "yet another id";
  const Json::Value* foundYetAnotherId =