Address pr comments

Author: cataphract

src/attribute_collector.hpp

@@ -40,7 +40,7 @@ class attribute_collector {
 public:
     explicit attribute_collector(
         nonnull_ptr<memory::memory_resource> alloc = memory::get_default_resource())
-        : attributes_(owned_object::make_map(0, alloc))
+        : attributes_(owned_object::make_map(alloc))
     {}
     attribute_collector(const attribute_collector &) = delete;
     attribute_collector &operator=(const attribute_collector &) = delete;
@@ -50,28 +50,28 @@ class attribute_collector {
 
     bool insert(std::string_view key, bool value)
     {
-        return insert(key, owned_object::make_boolean(value, attributes_.alloc()));
+        return insert(key, owned_object::make_boolean(value));
     }
 
     template <typename T>
     bool insert(std::string_view key, T value)
         requires std::is_integral_v<T> && std::is_signed_v<T>
     {
-        return insert(key, owned_object::make_signed(value, attributes_.alloc()));
+        return insert(key, owned_object::make_signed(value));
     }
 
     template <typename T>
     bool insert(std::string_view key, T value)
         requires std::is_integral_v<T> && std::is_unsigned_v<T> && (!std::same_as<T, bool>)
     {
-        return insert(key, owned_object::make_unsigned(value, attributes_.alloc()));
+        return insert(key, owned_object::make_unsigned(value));
     }
 
     template <typename T>
     bool insert(std::string_view key, T value)
         requires std::is_floating_point_v<T>
     {
-        return insert(key, owned_object::make_float(value, attributes_.alloc()));
+        return insert(key, owned_object::make_float(value));
     }
 
     template <typename T>
@@ -99,7 +99,7 @@ class attribute_collector {
     {
         auto output_object = std::move(attributes_);
         // Reset attributes
-        attributes_ = owned_object::make_map(0, output_object.alloc());
+        attributes_ = owned_object::make_map(output_object.alloc());
         inserted_.clear();
 
         return output_object;

src/dynamic_string.cpp

@@ -19,7 +19,7 @@ owned_object dynamic_string::to_object(nonnull_ptr<memory::memory_resource> allo
                                         // this means alloc (the deallocator for the owned_object)
                                         // can deallocate memory from alloc_ (the allocator for
                                         // this dynamic_string)
-                              owned_object::unsafe_make_string_nocopy(buffer_, size_, alloc);
+                              owned_object::make_string_nocopy(buffer_, size_, alloc);
 
     if (should_copy) {
         alloc_->deallocate(buffer_, capacity_, alignof(char));

src/interface.cpp

@@ -153,7 +153,7 @@ borrowed_object to_borrowed(ddwaf_object *ptr, nonnull_ptr<memory::memory_resour
 {
     // safety: caller is responsible for ensuring allocator matches object's memory
     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-    return borrowed_object::create_unchecked(reinterpret_cast<detail::object *>(ptr), alloc);
+    return borrowed_object{reinterpret_cast<detail::object *>(ptr), alloc};
 }
 
 memory::memory_resource *to_alloc_ptr(ddwaf_allocator alloc)
@@ -266,7 +266,7 @@ DDWAF_RET_CODE ddwaf_context_eval(ddwaf_context context, ddwaf_object *data,
             if (!context->insert(
                     // safety: caller is responsible to ensure that the passed
                     // allocator can deallocate memory allocated for `data`
-                    owned_object::create_unchecked(to_ref(data), to_alloc_ptr(alloc)))) {
+                    owned_object{to_ref(data), to_alloc_ptr(alloc)})) {
                 return DDWAF_ERR_INVALID_OBJECT;
             }
         } else {
@@ -338,7 +338,7 @@ DDWAF_RET_CODE ddwaf_subcontext_eval(ddwaf_subcontext subcontext, ddwaf_object *
             if (!subcontext->insert(
                     // safety: caller is responsible to ensure that the passed
                     // allocator can deallocate memory allocated for `data`
-                    owned_object::create_unchecked(to_ref(data), to_alloc_ptr(alloc)))) {
+                    owned_object{to_ref(data), to_alloc_ptr(alloc)})) {
                 return DDWAF_ERR_INVALID_OBJECT;
             }
         } else {
@@ -651,7 +651,7 @@ ddwaf_object *ddwaf_object_set_string_nocopy(
     // allocate from it and we forget it afterwards (we just care about the
     // detail::object part of the owned_object)
     to_ref(object) =
-        owned_object::unsafe_make_string_nocopy(string, length, memory::get_default_null_resource())
+        owned_object::make_string_nocopy(string, length, memory::get_default_null_resource())
             .move();
     return object;
 }
@@ -784,7 +784,7 @@ ddwaf_object *ddwaf_object_insert(ddwaf_object *array, ddwaf_allocator alloc)
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
         borrowed_object container = to_borrowed(array, alloc_ptr);
-        owned_object new_element = owned_object::make_uninit(alloc_ptr);
+        owned_object new_element = owned_object{alloc_ptr};
         borrowed_object inserted = container.emplace_back(std::move(new_element));
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
@@ -802,7 +802,7 @@ ddwaf_object *ddwaf_object_insert_key(
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
         borrowed_object container = to_borrowed(map, alloc_ptr);
-        owned_object new_value = owned_object::make_uninit(alloc_ptr);
+        owned_object new_value = owned_object{alloc_ptr};
         borrowed_object inserted =
             container.emplace(std::string_view{key, length}, std::move(new_value));
 
@@ -821,8 +821,8 @@ ddwaf_object *ddwaf_object_insert_key_nocopy(
 
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
-        auto key_obj = owned_object::unsafe_make_string_nocopy(key, length, alloc_ptr);
-        auto value_obj = owned_object::make_uninit(alloc_ptr);
+        auto key_obj = owned_object::make_string_nocopy(key, length, alloc_ptr);
+        auto value_obj = owned_object{alloc_ptr};
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return reinterpret_cast<ddwaf_object *>(
@@ -844,8 +844,8 @@ ddwaf_object *ddwaf_object_insert_literal_key(
 
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
-        auto key_obj = owned_object::make_string_literal(key, length, alloc_ptr);
-        auto value_obj = owned_object::make_uninit(alloc_ptr);
+        auto key_obj = owned_object::make_string_literal(key, length);
+        auto value_obj = owned_object{alloc_ptr};
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return reinterpret_cast<ddwaf_object *>(

src/json_utils.cpp

@@ -66,8 +66,7 @@ class object_reader_handler
     : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, object_reader_handler> {
 public:
     explicit object_reader_handler(nonnull_ptr<memory::memory_resource> alloc)
-        : alloc_(alloc), root_(owned_object::make_uninit(alloc)),
-          key_(owned_object::make_uninit(alloc))
+        : alloc_(alloc), root_(alloc), key_(alloc)
     {
         stack_.reserve(max_depth + 1);
     }
@@ -169,7 +168,7 @@ class object_reader_handler
             return true;
         }
 
-        return emplace(owned_object::make_map(0, alloc_));
+        return emplace(owned_object::make_map(alloc_));
     }
 
     // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
@@ -190,7 +189,7 @@ class object_reader_handler
             return true;
         }
 
-        return emplace(owned_object::make_array(0, alloc_));
+        return emplace(owned_object::make_array(alloc_));
     }
 
     // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
@@ -261,7 +260,7 @@ owned_object json_to_object(std::string_view json, nonnull_ptr<memory::memory_re
     const rapidjson::ParseResult res = reader.Parse(ss, handler);
     if (res.IsError()) {
         // Not interested in partial JSON for now
-        return owned_object::make_uninit(alloc);
+        return owned_object{alloc};
     }
 
     return handler.finalize();