[WIP] Add C++ bindings

1 files changed, 106 insertions, 0 deletions

diff --git a/bindings/cpp/include/serd/detail/Copyable.hpp b/bindings/cpp/include/serd/detail/Copyable.hpp
new file mode 100644
index 00000000..5a5b5cde
--- /dev/null
+++ b/bindings/cpp/include/serd/detail/Copyable.hpp
@@ -0,0 +1,106 @@
+// Copyright 2019-2021 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#ifndef SERD_DETAIL_COPYABLE_HPP
+#define SERD_DETAIL_COPYABLE_HPP
+
+// IWYU pragma: no_include "serd/serd.h"
+
+#include "serd/detail/Wrapper.hpp"
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace serd {
+namespace detail {
+
+/**
+   @addtogroup serdpp_detail
+   @{
+*/
+
+/// Copy function for an allocator-managed C object
+template<class T>
+using CopyFunc = Mutable<T>* (*)(ZixAllocator*, const T*);
+
+/// Equality comparison function for C objects
+template<class T>
+using EqualsFunc = bool (*)(const T*, const T*);
+
+template<class T, CopyFunc<T> copy_func>
+typename std::enable_if_t<std::is_const<T>::value, T>*
+copy_cobj(const T* ptr)
+{
+  return ptr; // Constant wrapper, do not copy
+}
+
+template<class T, CopyFunc<T> copy_func>
+typename std::enable_if_t<!std::is_const<T>::value, T>*
+copy_cobj(const T* ptr)
+{
+  return ptr ? copy_func(nullptr, ptr) : nullptr; // Mutable wrapper, copy
+}
+
+/**
+   Generic wrapper for a "basic" copyable object.
+
+   This wraps objects with simple ownership semantics where a const pointer is
+   never owned, and a mutable pointer is owned.  This has no space overhead
+   compared to a raw pointer since the ownership is encoded in the type.
+*/
+template<class T, class Deleter, CopyFunc<T> copy, EqualsFunc<T> equals>
+class Copyable : public Wrapper<T, Deleter>
+{
+public:
+  using Base = Wrapper<T, Deleter>;
+
+  explicit Copyable(T* ptr)
+    : Base{ptr}
+  {}
+
+  Copyable(const Copyable& wrapper)
+    : Base(copy_cobj<T, copy>(wrapper.cobj()))
+  {}
+
+  template<class U, class UDeleter>
+  explicit Copyable(const Copyable<U, UDeleter, copy, equals>& wrapper)
+    : Base(copy_cobj<T, copy>(wrapper.cobj()))
+  {}
+
+  Copyable(Copyable&&) noexcept            = default;
+  Copyable& operator=(Copyable&&) noexcept = default;
+
+  ~Copyable() noexcept = default;
+
+  Copyable& operator=(const Copyable& wrapper)
+  {
+    if (&wrapper != this) {
+      this->_ptr =
+        std::unique_ptr<T, Deleter>(copy_cobj<T, copy>(wrapper.cobj()));
+    }
+    return *this;
+  }
+
+  template<class U, class UDeleter, Mutable<T>* UCopy(ZixAllocator*, const T*)>
+  bool operator==(const Copyable<U, UDeleter, UCopy, equals>& wrapper) const
+  {
+    return equals(this->cobj(), wrapper.cobj());
+  }
+
+  template<class U, class UDeleter, Mutable<T>* UCopy(ZixAllocator*, const T*)>
+  bool operator!=(const Copyable<U, UDeleter, UCopy, equals>& wrapper) const
+  {
+    return !operator==(wrapper);
+  }
+};
+
+/**
+   @}
+*/
+
+} // namespace detail
+} // namespace serd
+
+#endif // SERD_DETAIL_COPYABLE_HPP