1 files changed, 0 insertions, 80 deletions
diff --git a/butl/const-ptr b/butl/const-ptr
deleted file mode 100644
index 2790253..0000000
--- a/butl/const-ptr
+++ /dev/null
@@ -1,80 +0,0 @@
-// file      : butl/const-ptr -*- C++ -*-
-// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
-// license   : MIT; see accompanying LICENSE file
-
-#ifndef BUTL_CONST_PTR
-#define BUTL_CONST_PTR
-
-#include <cstddef> // nullptr_t
-
-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_;
-  };
-}
-
-#endif // BUTL_CONST_PTR