zcpointer.h

   1 // Copyright 2016 Google Inc. All rights reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include <memory>
  16 #include <forward_list>
  17
  18 namespace zc {
  19
  20 #if defined(ZCPOINTER_TRACK_REFS) && ZCPOINTER_TRACK_REFS
  21
  22 template <typename T> class ref;
  23
  24 namespace internal {
  25
  26 template <typename T>
  27 class OwnedPtrDeleter {
  28  public:
  29   OwnedPtrDeleter() {}
  30   ~OwnedPtrDeleter() {}
  31
  32   OwnedPtrDeleter(OwnedPtrDeleter&& other) : refs_(std::move(other.refs_)) {
  33   }
  34
  35   void operator()(T* t) const {
  36     for (auto& ref : refs_) {
  37       ref->MarkDeleted();
  38     }
  39     delete t;
  40   }
  41
  42  protected:
  43   friend class ref<T>;
  44
  45   void AddRef(ref<T>* ref) {
  46     refs_.push_front(ref);
  47   }
  48
  49   void RemoveRef(ref<T>* ref) {
  50     refs_.remove(ref);
  51   }
  52
  53  private:
  54   std::forward_list<ref<T>*> refs_;
  55 };
  56
  57 void RaiseUseAfterFree(const char* error) __attribute__((noreturn));
  58
  59 }  // namespace internal
  60
  61 template <typename T>
  62 class owned : public std::unique_ptr<T, internal::OwnedPtrDeleter<T>> {
  63  private:
  64   using Deleter = internal::OwnedPtrDeleter<T>;
  65
  66  public:
  67   using std::unique_ptr<T, Deleter>::unique_ptr;
  68
  69   ref<T> get() {
  70     return ref<T>(*this);
  71   }
  72
  73  protected:
  74   friend class ref<T>;
  75
  76   T* GetRawPointer() const {
  77     return get();
  78   }
  79
  80  private:
  81   T* get() const {
  82     return this->std::unique_ptr<T, Deleter>::get();
  83   }
  84 };
  85
  86 template <typename T>
  87 class ref {
  88  public:
  89   explicit ref(owned<T>& o) : ptr_(o.GetRawPointer()), deleter_(o.get_deleter()) {
  90     deleter_.AddRef(this);
  91   }
  92
  93   ref(const ref<T>& o) : ptr_(o.ptr_), deleter_(o.deleter_), deleted_(o.deleted_) {
  94     if (!deleted_) {
  95       deleter_.AddRef(this);
  96     }
  97   }
  98
  99   ref<T>& operator=(ref<T> o) {
 100     return ref(o);
 101   }
 102
 103   ~ref() {
 104     MarkDeleted();
 105     deleter_.RemoveRef(this);
 106   }
 107
 108   T* operator->() const {
 109     CheckDeleted();
 110     return ptr_;
 111   }
 112
 113  protected:
 114   friend class internal::OwnedPtrDeleter<T>;
 115
 116   void MarkDeleted() {
 117     deleted_ = true;
 118   }
 119
 120  private:
 121   void CheckDeleted() const {
 122     if (deleted_) {
 123       internal::RaiseUseAfterFree("attempt to access deleted pointer");
 124     }
 125   }
 126
 127   T* ptr_;
 128   internal::OwnedPtrDeleter<T>& deleter_;
 129   bool deleted_ = false;
 130 };
 131
 132 #else
 133
 134 template <typename T>
 135 using owned = std::unique_ptr<T>;
 136
 137 template <typename T>
 138 using ref = T*;
 139
 140 #endif
 141
 142 }  // namespace zc