Fix compat with nlohmann::json

Author: lefticus

include/json2cpp/json2cpp.hpp

@@ -191,6 +191,8 @@ template<typename CharType> struct basic_json
 
   struct iterator
   {
+    constexpr iterator() noexcept = default;
+
     constexpr explicit iterator(const basic_json &value, std::size_t index = 0) noexcept
       : parent_value_(&value), index_{ index }
     {}
@@ -289,6 +291,8 @@ template<typename CharType> struct basic_json
 
   [[nodiscard]] constexpr std::size_t size() const noexcept { return size_; }
 
+  [[nodiscard]] constexpr bool empty() const noexcept { return size_ == 0; }
+
   [[nodiscard]] static constexpr std::size_t size(const basic_json &obj) noexcept
   {
     if (obj.is_null()) { return 0; }
@@ -308,16 +312,7 @@ template<typename CharType> struct basic_json
     }
   }
 
-  [[nodiscard]] constexpr iterator find(const std::basic_string_view<CharType> key) const noexcept
-  {
-    for (auto itr = begin(); itr != end(); ++itr) {
-      if (itr.key() == key) { return itr; }
-    }
-
-    return end();
-  }
-
-  [[nodiscard]] constexpr const basic_json &operator[](const std::basic_string_view<CharType> key) const
+  [[nodiscard]] constexpr const basic_json &at(const std::basic_string_view<CharType> key) const
   {
     const auto &children = object_data();
 
@@ -343,6 +338,33 @@ template<typename CharType> struct basic_json
     }
   }
 
+  template<typename Key>[[nodiscard]] constexpr std::size_t count(const Key &key) const noexcept
+  {
+    if (is_object()) {
+      const auto found = find(key);
+      if (found == end()) {
+        return 0;
+      } else {
+        return 1;
+      }
+    }
+    return 0;
+  }
+
+  [[nodiscard]] constexpr iterator find(const std::basic_string_view<CharType> key) const noexcept
+  {
+    for (auto itr = begin(); itr != end(); ++itr) {
+      if (itr.key() == key) { return itr; }
+    }
+
+    return end();
+  }
+
+  [[nodiscard]] constexpr const basic_json &operator[](const std::basic_string_view<CharType> key) const
+  {
+    return at(key);
+  }
+
   constexpr const auto &array_data() const
   {
     if (const auto *result = data.get_if_array(); result != nullptr) {
@@ -364,38 +386,35 @@ template<typename CharType> struct basic_json
   constexpr static basic_json object() { return basic_json{ data_t{ basic_object_t<CharType>{} } }; }
   constexpr static basic_json array() { return basic_json{ data_t{ basic_array_t<CharType>{} } }; }
 
-  template<typename Type>[[nodiscard]] constexpr Type get() const
+  template<typename Type>[[nodiscard]] constexpr auto get() const
   {
-    bool error = false;
-    if constexpr (std::is_same_v<Type, std::uint64_t> || std::is_same_v<Type, std::int64_t>) {
+    if constexpr (std::is_same_v<Type, std::uint64_t> || std::is_same_v<Type, std::int64_t> || std::is_same_v<Type, double>) {
       if (const auto *uint_value = data.get_if_uinteger(); uint_value != nullptr) {
         return Type(*uint_value);
       } else if (const auto *value = data.get_if_integer(); value != nullptr) {
         return Type(*value);
+      } else if (const auto *fpvalue = data.get_if_floating_point(); fpvalue != nullptr) {
+        return Type(*fpvalue);
+      } else {
+//        std::stringstream ss;
+ //       ss << is_string() << is_object() << is_array() << is_string() << is_boolean() << is_structured() << is_number() << is_null() << is_binary() << is_primitive();
+        throw std::runtime_error("Unexpected type: number requested");// + ss.str() );
       }
-      error = true;
-    } else if constexpr (std::is_same_v<Type, double>) {
-      if (const auto *value = data.get_if_floating_point(); value != nullptr) { return *value; }
-      error = true;
     } else if constexpr (std::is_same_v<Type,
                            std::basic_string_view<CharType>> || std::is_same_v<Type, std::basic_string<CharType>>) {
       if (const auto *value = data.get_if_string(); value != nullptr) { return *value; }
-      error = true;
+      else {
+        throw std::runtime_error("Unexpected type: string-like requested");
+      }
     } else if constexpr (std::is_same_v<Type, bool>) {
       if (const auto *value = data.get_if_boolean(); value != nullptr) { return *value; }
-      error = true;
+      else {
+        throw std::runtime_error("Unexpected type: bool requested");
+      }
     } else {
       throw std::runtime_error("Unexpected type for get()");
     }
 
-    if (error) {
-      // we have this boolean only because of a broken gcc implementation
-      // that incorrect says this is not a constexpr function
-      throw std::runtime_error("Type mismatch in get()");
-    } else {
-      // this code is terrible and it makes me sad
-      return Type{};
-    }
   }
 
   [[nodiscard]] constexpr bool is_object() const noexcept { return data.selected == data_t::selected_type::object; }
@@ -430,7 +449,7 @@ template<typename CharType> struct basic_json
 
 
   data_t data;
-  std::size_t size_{ size(*this) };
+  std::size_t size_{ basic_json::size(*this) };
 };
 
 using json = basic_json<char>;

include/json2cpp/json2cpp_adapter.hpp

@@ -49,7 +49,7 @@ SOFTWARE.
 
 #pragma once
 
-#include <json2cpp/json2cpp.hpp>
+#include "json2cpp.hpp"
 #include <string>
 
 #include <utility>