From 7f6015a81b5996e4a2877cb7b6ef407248a5dcf9 Mon Sep 17 00:00:00 2001
From: Vesa Karvonen <vesa.a.j.k@gmail.com>
Date: Sun, 13 Oct 2019 01:56:33 +0300
Subject: [PATCH] WIP

---
 .clang-format                                 |   4 +
 .cppsm                                        |   1 +
 .gitignore                                    |   1 +
 .gitmodules                                   |   4 +
 .prettierrc                                   |   7 +
 .travis.yml                                   |  24 +++
 CMakeLists.txt                                |   3 +
 internals/CMakeLists.txt                      |   1 +
 internals/testing/compile_synopsis_test.cpp   |  47 +++++
 provides/core/CMakeLists.txt                  |   1 +
 .../core/include/trade_core_v2/library.hpp    | 136 +++++++++++++
 .../core/include/trade_core_v2/private.hpp    | 114 +++++++++++
 .../core/include/trade_core_v2/synopsis.hpp   |  56 ++++++
 provides/full/CMakeLists.txt                  |   2 +
 provides/full/include/trade_v2/library.hpp    |   6 +
 provides/full/include/trade_v2/synopsis.hpp   |  11 ++
 provides/ptrs/CMakeLists.txt                  |   2 +
 .../ptrs/include/trade_ptrs_v2/library.hpp    | 181 ++++++++++++++++++
 .../ptrs/include/trade_ptrs_v2/private.hpp    |  70 +++++++
 .../ptrs/include/trade_ptrs_v2/synopsis.hpp   |  84 ++++++++
 20 files changed, 755 insertions(+)
 create mode 100644 .clang-format
 create mode 160000 .cppsm
 create mode 100644 .gitignore
 create mode 100644 .gitmodules
 create mode 100644 .prettierrc
 create mode 100644 .travis.yml
 create mode 100644 CMakeLists.txt
 create mode 100644 internals/CMakeLists.txt
 create mode 100644 internals/testing/compile_synopsis_test.cpp
 create mode 100644 provides/core/CMakeLists.txt
 create mode 100644 provides/core/include/trade_core_v2/library.hpp
 create mode 100644 provides/core/include/trade_core_v2/private.hpp
 create mode 100644 provides/core/include/trade_core_v2/synopsis.hpp
 create mode 100644 provides/full/CMakeLists.txt
 create mode 100644 provides/full/include/trade_v2/library.hpp
 create mode 100644 provides/full/include/trade_v2/synopsis.hpp
 create mode 100644 provides/ptrs/CMakeLists.txt
 create mode 100644 provides/ptrs/include/trade_ptrs_v2/library.hpp
 create mode 100644 provides/ptrs/include/trade_ptrs_v2/private.hpp
 create mode 100644 provides/ptrs/include/trade_ptrs_v2/synopsis.hpp

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..a7afac0
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,4 @@
+BinPackArguments: false
+BinPackParameters: false
+ColumnLimit: 80
+IndentWidth: 2
diff --git a/.cppsm b/.cppsm
new file mode 160000
index 0000000..82ee378
--- /dev/null
+++ b/.cppsm
@@ -0,0 +1 @@
+Subproject commit 82ee3785488605383bcc4eff65fcb82e3730a703
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..677a6fc
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.build*
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..38bfab5
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,4 @@
+[submodule ".cppsm"]
+	path = .cppsm
+	url = https://github.com/cppsm/cppsm-boilerplate.git
+	branch = master
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 0000000..3030ecd
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,7 @@
+{
+  "bracketSpacing": false,
+  "printWidth": 80,
+  "semi": false,
+  "singleQuote": true,
+  "proseWrap": "always"
+}
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..e1f37b4
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,24 @@
+language: cpp
+
+notifications:
+  email: false
+
+matrix:
+  include:
+    - os: linux
+      dist: xenial
+    - os: osx
+      osx_image: xcode10.2
+    - os: windows
+
+git:
+  depth: 1
+  submodules: false
+
+before_install:
+  - export -f travis_nanoseconds travis_time_start travis_time_finish
+  - if [ "$TRAVIS_OS_NAME" = windows ]; then choco upgrade -y git.install; fi
+
+script:
+  - if ! [ -x .cppsm/travis-ci ]; then git submodule --quiet update --init --no-recommend-shallow --depth 1 .cppsm; fi
+  - .cppsm/travis-ci
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..adc13f9
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.10)
+project(trade_cpp)
+include(.cppsm/c++17.cmake)
diff --git a/internals/CMakeLists.txt b/internals/CMakeLists.txt
new file mode 100644
index 0000000..5c836a4
--- /dev/null
+++ b/internals/CMakeLists.txt
@@ -0,0 +1 @@
+add_conventional_executable_tests(PRIVATE trade_v2)
diff --git a/internals/testing/compile_synopsis_test.cpp b/internals/testing/compile_synopsis_test.cpp
new file mode 100644
index 0000000..16a1d8d
--- /dev/null
+++ b/internals/testing/compile_synopsis_test.cpp
@@ -0,0 +1,47 @@
+#include "trade_v2/synopsis.hpp"
+
+static_assert(std::is_nothrow_swappable_v<trade_v2::sole_ptr<int>>);
+static_assert(sizeof(trade_v2::atom<int>));
+static_assert(sizeof(trade_v2::atom<trade_v2::sole_ptr<int>>));
+
+#include "trade_v2/library.hpp"
+
+#include <memory>
+
+int main() {
+  {
+    using t = int;
+    trade_v2::atom<t> x;
+    static_assert(trade_v2::atom_traits<t>::is_atomic);
+  }
+
+  {
+    using t = std::pair<int, bool>;
+    trade_v2::atom<t> x(101, false);
+  }
+
+  {
+    struct t {
+      size_t more;
+      size_t than;
+      size_t two_words;
+    };
+
+    static_assert(trade_v2::atom_traits<t>::is_trivial);
+  }
+
+  {
+    using t = std::shared_ptr<int>;
+    trade_v2::atom<t> x;
+    static_assert(!trade_v2::atom_traits<t>::is_trivial &&
+                  !trade_v2::atom_traits<t>::is_atomic);
+  }
+
+  {
+    using t = trade_v2::sole_ptr<int>;
+    trade_v2::atom<t> x;
+    static_assert(trade_v2::atom_traits<t>::is_atomic);
+  }
+
+  return 0;
+}
diff --git a/provides/core/CMakeLists.txt b/provides/core/CMakeLists.txt
new file mode 100644
index 0000000..9b80112
--- /dev/null
+++ b/provides/core/CMakeLists.txt
@@ -0,0 +1 @@
+add_conventional_library(trade_core_v2)
diff --git a/provides/core/include/trade_core_v2/library.hpp b/provides/core/include/trade_core_v2/library.hpp
new file mode 100644
index 0000000..1928a69
--- /dev/null
+++ b/provides/core/include/trade_core_v2/library.hpp
@@ -0,0 +1,136 @@
+#pragma once
+
+#include "trade_core_v2/synopsis.hpp"
+
+//
+
+template <template <class> class Derived,
+          class Value,
+          class Master,
+          class Readonly>
+Readonly
+trade_core_v2::Private::basic_traits<Derived, Value, Master, Readonly>::load(
+    const Master &from) {
+  return from;
+}
+
+template <template <class> class Derived,
+          class Value,
+          class Master,
+          class Readonly>
+void trade_core_v2::Private::basic_traits<Derived, Value, Master, Readonly>::
+    snap(const Master &from, std::aligned_union_t<1, Value> &to) {
+  new (&to) Value(from);
+}
+
+template <template <class> class Derived,
+          class Value,
+          class Master,
+          class Readonly>
+void trade_core_v2::Private::basic_traits<Derived, Value, Master, Readonly>::
+    commit(Value &from, Master &to) noexcept {
+  to = from;
+}
+
+//
+
+template <class Value>
+Value trade_core_v2::Private::atomic_traits<Value>::load(
+    const std::atomic<Value> &from) noexcept {
+  return from.load(std::memory_order_relaxed);
+}
+
+template <class Value>
+void trade_core_v2::Private::atomic_traits<Value>::snap(
+    const std::atomic<Value> &from,
+    std::aligned_union_t<1, Value> &to) noexcept {
+  new (&to) Value(load(from));
+}
+
+template <class Value>
+void trade_core_v2::Private::atomic_traits<Value>::commit(
+    Value &from, std::atomic<Value> &to) noexcept {
+  to.store(from, std::memory_order_relaxed);
+}
+
+//
+
+template <class Value>
+void trade_core_v2::Private::swappable_traits<Value>::commit(
+    Value &from, Value &to) noexcept {
+  std::swap(from, to);
+}
+
+//
+
+template <class Value>
+inline typename trade_core_v2::atom_traits<Value>::readonly_type
+trade_core_v2::atom_traits<Value>::load(const master_type &from) {
+  return Private::atom_traits<Value>::load(from);
+}
+
+template <class Value>
+inline void trade_core_v2::atom_traits<Value>::snap(
+    const master_type &from, std::aligned_union_t<1, value_type> &to) {
+  Private::atom_traits<Value>::snap(from, to);
+}
+
+template <class Value>
+inline void
+trade_core_v2::atom_traits<Value>::commit(value_type &from,
+                                          master_type &to) noexcept {
+  Private::atom_traits<Value>::commit(from, to);
+}
+
+// =============================================================================
+
+template <class Value>
+template <class... Forwardable>
+trade_core_v2::Private::atom<Value>::atom(Forwardable &&... value)
+    : m_master(std::forward<Forwardable>(value)...) {}
+
+//
+
+template <class Value> trade_core_v2::atom<Value>::~atom() {}
+
+template <class Value>
+template <class... Forwardable>
+trade_core_v2::atom<Value>::atom(Forwardable &&... value)
+    : Private::atom<Value>(std::forward<Forwardable>(value)...) {}
+
+template <class Value>
+const typename trade_core_v2::atom<Value>::value_type &
+trade_core_v2::atom<Value>::load() const {
+  throw this; // TODO
+}
+
+template <class Value>
+trade_core_v2::atom<Value>::operator const value_type &() const {
+  return load();
+}
+
+template <class Value>
+typename trade_core_v2::atom<Value>::readonly_type
+trade_core_v2::atom<Value>::atomic_load() const {
+  throw this; // TODO
+}
+
+template <class Value>
+template <class Forwardable>
+typename trade_core_v2::atom<Value>::value_type &
+trade_core_v2::atom<Value>::store(Forwardable &&value) {
+  throw value; // TODO
+}
+
+template <class Value>
+template <class Forwardable>
+typename trade_core_v2::atom<Value>::value_type &
+trade_core_v2::atom<Value>::operator=(Forwardable &&value) {
+  store(std::forward<Forwardable>(value));
+}
+
+template <class Value>
+typename trade_core_v2::atom<Value>::value_type &
+trade_core_v2::atom<Value>::ref() {
+  throw this; // TODO
+}
diff --git a/provides/core/include/trade_core_v2/private.hpp b/provides/core/include/trade_core_v2/private.hpp
new file mode 100644
index 0000000..45ecd41
--- /dev/null
+++ b/provides/core/include/trade_core_v2/private.hpp
@@ -0,0 +1,114 @@
+#pragma once
+
+#include <atomic>
+#include <type_traits>
+#include <utility>
+
+namespace trade_core_v2 {
+
+template <class Value> struct atom;
+
+template <class Value> struct atom_traits;
+
+class Private {
+  template <class> friend struct ::trade_core_v2::atom;
+
+  template <class> class atom;
+
+  template <template <class> class Derived,
+            class Value,
+            class Master = Value,
+            class Readonly = Value>
+  struct basic_traits;
+
+  template <class> struct atomic_traits;
+  template <class> struct trivial_traits;
+  template <class> struct swappable_traits;
+
+  template <class Value> static constexpr auto trait_of();
+
+public:
+  template <class Value> struct atom_traits;
+};
+
+} // namespace trade_core_v2
+
+template <class Value> class trade_core_v2::Private::atom {
+  template <class> friend struct trade_core_v2::atom;
+
+  using master_type = typename trade_core_v2::atom_traits<Value>::master_type;
+
+  master_type m_master;
+
+  template <class... Forwardable> atom(Forwardable &&... value);
+};
+
+//
+
+template <template <class> class Derived,
+          class Value,
+          class Master,
+          class Readonly>
+struct trade_core_v2::Private::basic_traits {
+  using value_type = Value;
+  using readonly_type = Readonly;
+  using master_type = Master;
+
+  static constexpr bool is_atomic = false;
+  static constexpr bool is_trivial = false;
+
+  static Readonly load(const Master &from);
+
+  static void snap(const Master &from, std::aligned_union_t<1, Value> &to);
+
+  static void commit(Value &from, Master &to) noexcept;
+};
+
+template <class Value>
+struct trade_core_v2::Private::atomic_traits
+    : basic_traits<atomic_traits, Value, std::atomic<Value>> {
+  static constexpr bool is_atomic = true;
+  static constexpr bool is_trivial = true;
+
+  static Value load(const std::atomic<Value> &from) noexcept;
+
+  static void snap(const std::atomic<Value> &from,
+                   std::aligned_union_t<1, Value> &to) noexcept;
+
+  static void commit(Value &from, std::atomic<Value> &to) noexcept;
+};
+
+template <class Value>
+struct trade_core_v2::Private::trivial_traits
+    : basic_traits<trivial_traits, Value> {
+  static constexpr bool is_trivial = true;
+};
+
+template <class Value>
+struct trade_core_v2::Private::swappable_traits
+    : basic_traits<swappable_traits, Value> {
+  static void commit(Value &from, Value &to) noexcept;
+};
+
+//
+
+template <class Value> constexpr auto trade_core_v2::Private::trait_of() {
+  static_assert(std::is_copy_constructible_v<Value> &&
+                std::is_nothrow_destructible_v<Value> &&
+                std::is_nothrow_move_constructible_v<Value>);
+  if constexpr (std::is_trivially_copyable_v<Value>) {
+    static_assert(std::is_nothrow_copy_assignable_v<Value>);
+    if constexpr (std::atomic<Value>::is_always_lock_free) {
+      return static_cast<atomic_traits<Value> *>(nullptr);
+    } else {
+      return static_cast<trivial_traits<Value> *>(nullptr);
+    }
+  } else {
+    static_assert(std::is_nothrow_swappable_v<Value>);
+    return static_cast<swappable_traits<Value> *>(nullptr);
+  }
+}
+
+template <class Value>
+struct trade_core_v2::Private::atom_traits
+    : std::remove_pointer_t<decltype(trait_of<Value>())> {};
diff --git a/provides/core/include/trade_core_v2/synopsis.hpp b/provides/core/include/trade_core_v2/synopsis.hpp
new file mode 100644
index 0000000..0cebbc5
--- /dev/null
+++ b/provides/core/include/trade_core_v2/synopsis.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "trade_core_v2/private.hpp"
+
+// =============================================================================
+
+namespace trade_core_v2 {
+
+template <class Value> struct atom : Private::atom<Value> {
+  using value_type = typename atom_traits<Value>::value_type;
+  using readonly_type = typename atom_traits<Value>::readonly_type;
+
+  ~atom();
+
+  template <class... Forwardable> atom(Forwardable &&... value);
+
+  const value_type &load() const;
+  operator const value_type &() const;
+
+  readonly_type atomic_load() const;
+
+  template <class Forwardable> value_type &store(Forwardable &&value);
+  template <class Forwardable> value_type &operator=(Forwardable &&value);
+
+  value_type &ref();
+
+  atom(const atom &) = delete;
+  atom &operator=(const atom &that) = delete;
+};
+
+template <class Action>
+std::invoke_result_t<Action> atomically(Action &&action);
+
+} // namespace trade_core_v2
+
+// =============================================================================
+
+namespace trade_core_v2 {
+
+template <class Value> struct atom_traits {
+  using value_type = typename Private::atom_traits<Value>::value_type;
+  using master_type = typename Private::atom_traits<Value>::master_type;
+  using readonly_type = typename Private::atom_traits<Value>::readonly_type;
+
+  static constexpr bool is_atomic = Private::atom_traits<Value>::is_atomic;
+  static constexpr bool is_trivial = Private::atom_traits<Value>::is_trivial;
+
+  static readonly_type load(const master_type &from);
+
+  static void snap(const master_type &from,
+                   std::aligned_union_t<1, value_type> &to);
+
+  static void commit(value_type &from, master_type &to) noexcept;
+};
+
+} // namespace trade_core_v2
diff --git a/provides/full/CMakeLists.txt b/provides/full/CMakeLists.txt
new file mode 100644
index 0000000..9c1bd57
--- /dev/null
+++ b/provides/full/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_conventional_library(trade_v2)
+target_link_libraries(trade_v2 INTERFACE trade_core_v2 trade_ptrs_v2)
diff --git a/provides/full/include/trade_v2/library.hpp b/provides/full/include/trade_v2/library.hpp
new file mode 100644
index 0000000..d87e4ae
--- /dev/null
+++ b/provides/full/include/trade_v2/library.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "trade_core_v2/library.hpp"
+#include "trade_ptrs_v2/library.hpp"
+
+#include "trade_v2/synopsis.hpp"
diff --git a/provides/full/include/trade_v2/synopsis.hpp b/provides/full/include/trade_v2/synopsis.hpp
new file mode 100644
index 0000000..5728974
--- /dev/null
+++ b/provides/full/include/trade_v2/synopsis.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "trade_core_v2/synopsis.hpp"
+#include "trade_ptrs_v2/synopsis.hpp"
+
+namespace trade_v2 {
+
+using namespace trade_core_v2;
+using namespace trade_ptrs_v2;
+
+} // namespace trade_v2
diff --git a/provides/ptrs/CMakeLists.txt b/provides/ptrs/CMakeLists.txt
new file mode 100644
index 0000000..54f6ece
--- /dev/null
+++ b/provides/ptrs/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_conventional_library(trade_ptrs_v2)
+target_link_libraries(trade_ptrs_v2 INTERFACE trade_core_v2)
diff --git a/provides/ptrs/include/trade_ptrs_v2/library.hpp b/provides/ptrs/include/trade_ptrs_v2/library.hpp
new file mode 100644
index 0000000..1f30df8
--- /dev/null
+++ b/provides/ptrs/include/trade_ptrs_v2/library.hpp
@@ -0,0 +1,181 @@
+#pragma once
+
+#include "trade_ptrs_v2/synopsis.hpp"
+
+#include "trade_core_v2/library.hpp"
+
+//
+
+template <class Type>
+trade_ptrs_v2::Private::master_ptr<Type>::~master_ptr() noexcept {
+  ptr_traits<Type>::destroy(load());
+}
+
+template <class Type>
+trade_ptrs_v2::Private::master_ptr<Type>::master_ptr(pointer pointer) noexcept
+    : m_pointer(pointer) {}
+
+template <class Type>
+typename trade_ptrs_v2::ptr_traits<Type>::pointer
+trade_ptrs_v2::Private::master_ptr<Type>::load() const noexcept {
+  return m_pointer.load(std::memory_order_relaxed);
+}
+
+template <class Type>
+void trade_ptrs_v2::Private::master_ptr<Type>::store(pointer pointer) noexcept {
+  m_pointer.store(pointer, std::memory_order_relaxed);
+}
+
+//
+
+template <class Type>
+typename trade_ptrs_v2::sole_ptr<Type>::pointer
+    trade_ptrs_v2::sole_ptr<Type>::operator->() const noexcept {
+  return this->m_pointer;
+}
+
+template <class Type>
+std::add_lvalue_reference_t<
+    typename trade_ptrs_v2::sole_ptr<Type>::element_type>
+    trade_ptrs_v2::sole_ptr<Type>::operator*() const {
+  return ptr_traits<Type>::dereference(this->m_pointer);
+}
+
+template <class Type>
+typename trade_ptrs_v2::sole_ptr<Type>::element_type &
+    trade_ptrs_v2::sole_ptr<Type>::operator[](std::size_t nth) const {
+  return ptr_traits<Type>::index(this->m_pointer, nth);
+}
+
+template <class Type>
+void trade_ptrs_v2::sole_ptr<Type>::swap(sole_ptr &that) noexcept {
+  std::swap(this->m_pointer, that.m_pointer);
+}
+
+template <class Type>
+trade_ptrs_v2::sole_ptr<Type> &
+trade_ptrs_v2::sole_ptr<Type>::operator=(sole_ptr &&that) {
+  if (this != &that) {
+    this->m_pointer = that.m_pointer;
+    that.m_pointer = nullptr;
+  }
+  return *this;
+}
+
+template <class Type>
+trade_ptrs_v2::sole_ptr<Type> &
+trade_ptrs_v2::sole_ptr<Type>::operator=(std::nullptr_t) {
+  this->m_pointer = nullptr;
+  return *this;
+}
+
+template <class Type>
+bool trade_ptrs_v2::sole_ptr<Type>::operator!() const noexcept {
+  return !this->m_pointer;
+}
+
+template <class Type>
+trade_ptrs_v2::sole_ptr<Type>::operator bool() const noexcept {
+  return !!this->m_pointer;
+}
+
+template <class Type>
+typename trade_ptrs_v2::sole_ptr<Type>::pointer
+trade_ptrs_v2::sole_ptr<Type>::get() const noexcept {
+  return this->m_pointer;
+}
+
+//
+
+template <class Type>
+typename trade_ptrs_v2::ptr_traits<Type>::pointer
+trade_core_v2::atom_traits<trade_ptrs_v2::sole_ptr<Type>>::load(
+    const master_type &from) noexcept {
+  return from.load();
+}
+
+template <class Type>
+void trade_core_v2::atom_traits<trade_ptrs_v2::sole_ptr<Type>>::snap(
+    const master_type &from, std::aligned_union_t<1, value_type> &to) {
+  reinterpret_cast<value_type *>(&to)->m_pointer = from.load();
+}
+
+template <class Type>
+std::optional<typename trade_core_v2::atom_traits<
+    trade_ptrs_v2::sole_ptr<Type>>::master_type>
+trade_core_v2::atom_traits<trade_ptrs_v2::sole_ptr<Type>>::commit(
+    value_type &from, master_type &to) noexcept {
+  auto p_from = from.load();
+  auto p_to = to.load();
+  if (p_from != p_to) {
+    from.store(p_to);
+    if (p_from)
+      return std::make_optional(master_type(p_from));
+  }
+  return std::nullopt;
+}
+
+//
+
+template <class Object>
+void trade_ptrs_v2::Private::ptr_traits<Object>::destroy(pointer ptr) noexcept {
+  delete ptr;
+}
+
+template <class Object>
+Object *
+trade_ptrs_v2::Private::ptr_traits<Object>::arrow(pointer ptr) noexcept {
+  return ptr;
+}
+
+template <class Object>
+std::add_lvalue_reference_t<Object>
+trade_ptrs_v2::Private::ptr_traits<Object>::dereference(pointer ptr) {
+  return *ptr;
+}
+
+template <class Element>
+void trade_ptrs_v2::Private::ptr_traits<Element[]>::destroy(
+    pointer ptr) noexcept {
+  delete[] ptr;
+}
+
+template <class Element>
+Element &trade_ptrs_v2::Private::ptr_traits<Element[]>::index(pointer ptr,
+                                                              std::size_t nth) {
+  return ptr[nth];
+}
+
+//
+
+template <class Type>
+inline void trade_ptrs_v2::ptr_traits<Type>::destroy(pointer ptr) noexcept {
+  Private::ptr_traits<Type>::destroy(ptr);
+}
+
+template <class Type>
+inline typename trade_ptrs_v2::ptr_traits<Type>::pointer
+trade_ptrs_v2::ptr_traits<Type>::arrow(pointer ptr) noexcept {
+  return Private::ptr_traits<Type>::arrow(ptr);
+}
+
+template <class Type>
+inline std::add_lvalue_reference_t<
+    typename trade_ptrs_v2::ptr_traits<Type>::element_type>
+trade_ptrs_v2::ptr_traits<Type>::dereference(pointer ptr) {
+  return Private::ptr_traits<Type>::dereference(ptr);
+}
+
+template <class Type>
+inline typename trade_ptrs_v2::ptr_traits<Type>::element_type &
+trade_ptrs_v2::ptr_traits<Type>::index(pointer ptr, std::size_t nth) {
+  return Private::ptr_traits<Type>::index(ptr, nth);
+}
+
+//
+
+template <class Type>
+void trade_ptrs_v2::swap(trade_ptrs_v2::sole_ptr<Type> &lhs,
+                         trade_ptrs_v2::sole_ptr<Type> &rhs) noexcept {
+  lhs.swap(rhs);
+}
diff --git a/provides/ptrs/include/trade_ptrs_v2/private.hpp b/provides/ptrs/include/trade_ptrs_v2/private.hpp
new file mode 100644
index 0000000..dcfaf20
--- /dev/null
+++ b/provides/ptrs/include/trade_ptrs_v2/private.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include "trade_core_v2/synopsis.hpp"
+
+namespace trade_ptrs_v2 {
+
+template <class Type> struct sole_ptr;
+
+template <class Type> struct ptr_traits;
+
+class Private {
+  template <class> friend struct trade_ptrs_v2::sole_ptr;
+
+  template <class> friend struct trade_core_v2::atom_traits;
+
+  template <class Type> class sole_ptr;
+
+  template <class Type> struct master_ptr;
+
+public:
+  template <class Type> struct ptr_traits;
+};
+
+} // namespace trade_ptrs_v2
+
+template <class Type> class trade_ptrs_v2::Private::sole_ptr {
+  friend struct trade_ptrs_v2::sole_ptr<Type>;
+  friend struct trade_core_v2::atom_traits<trade_ptrs_v2::sole_ptr<Type>>;
+
+  typename trade_ptrs_v2::ptr_traits<Type>::pointer m_pointer;
+};
+
+template <class Type> struct trade_ptrs_v2::Private::master_ptr {
+  friend struct trade_core_v2::atom_traits<trade_ptrs_v2::sole_ptr<Type>>;
+
+  using pointer = typename trade_ptrs_v2::ptr_traits<Type>::pointer;
+
+  std::atomic<pointer> m_pointer;
+
+  ~master_ptr() noexcept;
+  master_ptr(pointer pointer = nullptr) noexcept;
+
+  pointer load() const noexcept;
+  void store(pointer pointer) noexcept;
+
+  master_ptr(const master_ptr &) = delete;
+  master_ptr &operator=(const master_ptr &) = delete;
+};
+
+//
+
+template <class Object> struct trade_ptrs_v2::Private::ptr_traits {
+  using pointer = Object *;
+  using element_type = Object;
+
+  static void destroy(pointer ptr) noexcept;
+
+  static Object *arrow(pointer ptr) noexcept;
+
+  static std::add_lvalue_reference_t<element_type> dereference(pointer ptr);
+};
+
+template <class Element> struct trade_ptrs_v2::Private::ptr_traits<Element[]> {
+  using pointer = Element *;
+  using element_type = Element;
+
+  static void destroy(pointer ptr) noexcept;
+
+  static Element &index(pointer ptr, std::size_t nth);
+};
diff --git a/provides/ptrs/include/trade_ptrs_v2/synopsis.hpp b/provides/ptrs/include/trade_ptrs_v2/synopsis.hpp
new file mode 100644
index 0000000..88fa8f0
--- /dev/null
+++ b/provides/ptrs/include/trade_ptrs_v2/synopsis.hpp
@@ -0,0 +1,84 @@
+#pragma once
+
+#include "trade_ptrs_v2/private.hpp"
+
+#include <optional>
+
+// =============================================================================
+
+namespace trade_ptrs_v2 {
+
+template <class Type> struct sole_ptr : Private::sole_ptr<Type> {
+  using pointer = typename ptr_traits<Type>::pointer;
+  using element_type = typename ptr_traits<Type>::element_type;
+
+  pointer operator->() const noexcept;
+
+  std::add_lvalue_reference_t<element_type> operator*() const;
+
+  element_type &operator[](std::size_t i) const;
+
+  void swap(sole_ptr &that) noexcept;
+
+  sole_ptr &operator=(sole_ptr &&that);
+  sole_ptr &operator=(std::nullptr_t);
+
+  bool operator!() const noexcept;
+  operator bool() const noexcept;
+
+  pointer get() const noexcept;
+
+  ~sole_ptr() = delete;
+
+  sole_ptr() = delete;
+  sole_ptr(const sole_ptr &) = delete;
+
+  sole_ptr &operator=(const sole_ptr &) = delete;
+};
+
+template <class Type>
+void swap(sole_ptr<Type> &lhs, sole_ptr<Type> &rhs) noexcept;
+
+} // namespace trade_ptrs_v2
+
+// =============================================================================
+
+namespace trade_ptrs_v2 {
+
+template <class Type> struct ptr_traits {
+  using pointer = typename Private::ptr_traits<Type>::pointer;
+  using element_type = typename Private::ptr_traits<Type>::element_type;
+
+  static void destroy(pointer ptr) noexcept;
+
+  static pointer arrow(pointer ptr) noexcept;
+
+  static std::add_lvalue_reference_t<element_type> dereference(pointer ptr);
+
+  static element_type &index(pointer ptr, std::size_t nth);
+};
+
+} // namespace trade_ptrs_v2
+
+// =============================================================================
+
+namespace trade_core_v2 {
+
+template <class Type> struct atom_traits<trade_ptrs_v2::sole_ptr<Type>> {
+  using value_type = trade_ptrs_v2::sole_ptr<Type>;
+  using master_type = trade_ptrs_v2::Private::master_ptr<Type>;
+  using readonly_type = typename trade_ptrs_v2::ptr_traits<Type>::pointer;
+
+  static constexpr bool is_atomic = true;
+  static constexpr bool is_trivial = false;
+
+  static readonly_type load(const master_type &from) noexcept;
+
+  static void snap(const master_type &from,
+                   std::aligned_union_t<1, value_type> &to);
+
+  static std::optional<master_type> commit(value_type &from,
+                                           master_type &to) noexcept;
+};
+
+} // namespace trade_core_v2

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://clevelandohioweatherforecast.com/php-proxy/index.php?q=https://github.com/per-framework/trade.cpp/compare/v1...v2.patch" target="_blank">Alternative Proxy</a></p><p><a href="http://clevelandohioweatherforecast.com/pFad/index.php?u=https://github.com/per-framework/trade.cpp/compare/v1...v2.patch" target="_blank">pFad Proxy</a></p><p><a href="http://clevelandohioweatherforecast.com/pFad/v3index.php?u=https://github.com/per-framework/trade.cpp/compare/v1...v2.patch" target="_blank">pFad v3 Proxy</a></p><p><a href="http://clevelandohioweatherforecast.com/pFad/v4index.php?u=https://github.com/per-framework/trade.cpp/compare/v1...v2.patch" target="_blank">pFad v4 Proxy</a></p></body>
</html>