From c09cd7512491cee1e82c1ad8128ce9fd4bc3f79b Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Fri, 22 Sep 2017 23:32:28 +0200
Subject: Initial modularization with both Clang and VC hacks

Note: gave up on VC about half way though.
---
 libbutl/const-ptr.mxx | 94 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 libbutl/const-ptr.mxx

(limited to 'libbutl/const-ptr.mxx')

diff --git a/libbutl/const-ptr.mxx b/libbutl/const-ptr.mxx
new file mode 100644
index 0000000..a4b86be
--- /dev/null
+++ b/libbutl/const-ptr.mxx
@@ -0,0 +1,94 @@
+// file      : libbutl/const-ptr.mxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef __cpp_modules
+#pragma once
+#endif
+
+// C includes.
+
+#ifndef __cpp_lib_modules
+#include <cstddef> // nullptr_t
+#endif
+
+// Other includes.
+
+#ifdef __cpp_modules
+export module butl.const_ptr;
+#ifdef __cpp_lib_modules
+import std.core; // @@ MOD std.fundamental.
+#endif
+#endif
+
+#include <libbutl/export.hxx>
+
+LIBBUTL_MODEXPORT namespace butl
+{
+  // Const-propagating pointer.
+  //
+  // It has the semantics of a raw pointer except that it passes on its own
+  // const-ness to the pointed-to object. In other words, if you have a const
+  // instance of this pointer, then you can only obtain a const raw pointer to
+  // the underlying object. It is normally used as a data member, for example:
+  //
+  // struct tree
+  // {
+  //   const_ptr<tree> left;
+  //   const_ptr<tree> right;
+  //
+  //   void modify ();
+  // };
+  //
+  //       tree* x = ...;
+  // const tree* y = ...;
+  //
+  // x.left->modify (); // Ok.
+  // y.left->modify (); // Error.
+  //
+  // Note that due to this semantics, copy construction/assignment requires
+  // a non-const instance of const_ptr.
+  //
+  // Note that this type is standard layout (which means we can reinterpret
+  // it as a raw pointer).
+  //
+  // Known drawbacks/issues:
+  //
+  // 1. Cannot do static_cast<mytree*> (x.left).
+  //
+  template <typename T>
+  class const_ptr
+  {
+  public:
+    const_ptr () = default;
+    explicit const_ptr (T* p): p_ (p) {}
+    const_ptr (std::nullptr_t): p_ (nullptr) {}
+
+    const_ptr& operator= (T* p) {p_ = p; return *this;}
+    const_ptr& operator= (std::nullptr_t) {p_ = nullptr; return *this;}
+
+    template <class T1> explicit const_ptr (T1* p): p_ (p) {}
+    template <class T1> const_ptr (const_ptr<T1>& p): p_ (p.p_) {}
+
+    template <class T1> const_ptr& operator= (T1* p) {p_ = p; return *this;}
+    template <class T1> const_ptr& operator= (const_ptr<T1>& p) {
+      p_ = p.p_; return *this;}
+
+    T*       operator-> ()       {return p_;}
+    const T* operator-> () const {return p_;}
+
+    T&       operator* ()       {return *p_;}
+    const T& operator* () const {return *p_;}
+
+    operator       T* ()       {return p_;}
+    operator const T* () const {return p_;}
+
+    explicit operator bool () const {return p_ != nullptr;}
+
+    T*       get ()       {return p_;}
+    const T* get () const {return p_;}
+
+  private:
+    T* p_;
+  };
+}
-- 
cgit v1.1