Add value_ptr (#59)

Implement value_ptr

CMakeLists.txt

@@ -61,11 +61,12 @@ endif()
 set(SPARROW_HEADERS
  ${SPARROW_INCLUDE_DIR}/sparrow/array_data.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/buffer.hpp
- ${SPARROW_INCLUDE_DIR}/sparrow/fixed_size_layout.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/data_type.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/data_traits.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/dynamic_bitset.hpp
+ ${SPARROW_INCLUDE_DIR}/sparrow/fixed_size_layout.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/iterator.hpp
+ ${SPARROW_INCLUDE_DIR}/sparrow/memory.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/mp_utils.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/sparrow_version.hpp
  ${SPARROW_INCLUDE_DIR}/sparrow/variable_size_binary_layout.hpp

include/sparrow/array_data.hpp

@@ -16,13 +16,13 @@
 
 #include <cassert>
 #include <compare>
-#include <concepts>
 #include <optional>
 #include <vector>
 
 #include "sparrow/buffer.hpp"
 #include "sparrow/data_type.hpp"
 #include "sparrow/dynamic_bitset.hpp"
+#include "sparrow/memory.hpp"
 
 namespace sparrow
 {
@@ -48,7 +48,7 @@ namespace sparrow
  // Other buffers
  std::vector<buffer_type> buffers;
  std::vector<array_data> child_data;
- std::shared_ptr<array_data> dictionary;
+ value_ptr<array_data> dictionary;
  };
 
  /**

include/sparrow/memory.hpp

@@ -0,0 +1,123 @@
+// Copyright 2024 Man Group Operations Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or mplied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cassert>
+#include <memory>
+
+namespace sparrow
+{
+
+ /**
+ * @brief A value_ptr is a smart pointer that behaves like a value.
+ * It manages the lifetime of an object of type T which is not stored in the `value_ptr` but a pointer,
+ * similar to `unique_ptr`. When copied, it copies the managed object.
+ *
+ * @tparam T The type of the object managed by the `value_ptr`.
+ * @todo Make it constexpr.
+ */
+ template <class T>
+ class value_ptr
+ {
+ public:
+
+ value_ptr() = default;
+
+ explicit value_ptr(T value)
+ : value_(std::make_unique<T>(std::move(value)))
+ {
+ }
+
+ explicit value_ptr(T* value)
+ : value_(value != nullptr ? std::make_unique<T>(*value) : std::unique_ptr<T>())
+ {
+ }
+
+ value_ptr(const value_ptr& other)
+ : value_(other.value_ ? std::make_unique<T>(*other.value_) : std::unique_ptr<T>())
+ {
+ }
+
+ value_ptr(value_ptr&& other) noexcept = default;
+
+ ~value_ptr() = default;
+
+ value_ptr& operator=(const value_ptr& other)
+ {
+ if (other.has_value())
+ {
+ if (value_)
+ {
+ *value_ = *other.value_;
+ }
+ else
+ {
+ value_ = std::make_unique<T>(*other.value_);
+ }
+ }
+ else
+ {
+ value_.reset();
+ }
+ return *this;
+ }
+
+ value_ptr& operator=(value_ptr&& other) noexcept = default;
+
+ T& operator*()
+ {
+ assert(value_);
+ return *value_;
+ }
+
+ const T& operator*() const
+ {
+ assert(value_);
+ return *value_;
+ }
+
+ T* operator->()
+ {
+ assert(value_);
+ return &*value_;
+ }
+
+ const T* operator->() const
+ {
+ assert(value_);
+ return &*value_;
+ }
+
+ explicit operator bool() const noexcept
+ {
+ return has_value();
+ }
+
+ bool has_value() const noexcept
+ {
+ return bool(value_);
+ }
+
+ void reset() noexcept
+ {
+ value_.reset();
+ }
+
+ private:
+
+ std::unique_ptr<T> value_;
+ };
+
+}

test/CMakeLists.txt

@@ -43,6 +43,7 @@ set(SPARROW_TESTS_SOURCES
  test_dictionary_encoded_layout.cpp
  test_mpl.cpp
  test_traits.cpp
+ test_memory.cpp
 )
 set(test_target "test_sparrow_lib")
 add_executable(${test_target} ${SPARROW_TESTS_SOURCES})

test/test_dictionary_encoded_layout.cpp

@@ -43,7 +43,7 @@ namespace sparrow
  m_data.buffers.push_back(b);
  m_data.length = element_count;
  auto dictionary = make_dictionary();
- m_data.dictionary = std::make_shared<array_data>(std::move(dictionary));
+ m_data.dictionary = sparrow::value_ptr<array_data>(std::move(dictionary));
  }
 
  static array_data make_dictionary()

test/test_memory.cpp

@@ -0,0 +1,149 @@
+// Copyright 2024 Man Group Operations Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <vector>
+
+#include "sparrow/memory.hpp"
+
+#include "doctest/doctest.h"
+
+using namespace sparrow;
+
+TEST_SUITE("value_ptr")
+{
+ TEST_CASE("constructor")
+ {
+ value_ptr<int> vp;
+ CHECK(!vp);
+
+ value_ptr vp1(42);
+ REQUIRE(vp1);
+ CHECK_EQ(*vp1, 42);
+ }
+
+ TEST_CASE("copy constructor")
+ {
+ const value_ptr vp1(42);
+ const value_ptr vp2(vp1);
+ REQUIRE(vp1);
+ REQUIRE(vp2);
+ CHECK_EQ(*vp1, 42);
+ CHECK_EQ(*vp2, 42);
+ }
+
+ TEST_CASE("copy constructor with nullptr")
+ {
+ const value_ptr<int> vp1;
+ const value_ptr<int> vp2(vp1);
+ CHECK(!vp1);
+ CHECK(!vp2);
+ }
+
+ TEST_CASE("operator=")
+ {
+ value_ptr<int> vp1;
+ value_ptr<int> vp2(42);
+ vp1 = vp2;
+ REQUIRE(vp1);
+ REQUIRE(vp2);
+ CHECK_EQ(*vp1, 42);
+ CHECK_EQ(*vp2, 42);
+
+ value_ptr<int> vp3;
+ value_ptr<int> vp4;
+ vp3 = vp4;
+ CHECK(!vp3);
+ CHECK(!vp4);
+ }
+
+ TEST_CASE("copy")
+ {
+ const value_ptr vp1(42);
+ const value_ptr vp2 = vp1;
+ REQUIRE(vp1);
+ REQUIRE(vp2);
+ CHECK_EQ(*vp1, 42);
+ CHECK_EQ(*vp2, 42);
+ }
+
+ TEST_CASE("move constructor")
+ {
+ value_ptr vp1(42);
+ const value_ptr vp2(std::move(vp1));
+ CHECK(!vp1);
+ REQUIRE(vp2);
+ CHECK_EQ(*vp2, 42);
+ }
+
+ TEST_CASE("move assignment")
+ {
+ value_ptr vp1(42);
+ value_ptr<int> vp2;
+ vp2 = std::move(vp1);
+ CHECK(!vp1);
+ REQUIRE(vp2);
+ CHECK_EQ(*vp2, 42);
+
+ value_ptr<int> vp3;
+ {
+ value_ptr vp4(43);
+ vp3 = std::move(vp4);
+ }
+ REQUIRE(vp3);
+ CHECK_EQ(*vp3, 43);
+ }
+
+ TEST_CASE("operator*")
+ {
+ value_ptr vp(42);
+ CHECK_EQ(*vp, 42);
+
+ *vp = 43;
+ CHECK_EQ(*vp, 43);
+ }
+
+ TEST_CASE("operator->")
+ {
+ value_ptr vp(std::vector<int>{42});
+ CHECK_EQ(vp.operator->(), std::addressof(*vp));
+ CHECK_EQ(vp->size(), 1);
+ CHECK_EQ(vp->at(0), 42);
+ }
+
+ TEST_CASE("operator bool")
+ {
+ value_ptr<int> vp;
+ CHECK(!vp);
+
+ value_ptr vp1(42);
+ CHECK(vp1);
+ }
+
+ TEST_CASE("has_value")
+ {
+ value_ptr<int> vp;
+ CHECK(!vp.has_value());
+
+ value_ptr vp1(42);
+ CHECK(vp1.has_value());
+ }
+
+ TEST_CASE("reset")
+ {
+ value_ptr vp(42);
+ REQUIRE(vp);
+ vp.reset();
+ CHECK(!vp);
+ }
+}