memory.h 13.3 KB
Newer Older
Kenton Varda's avatar
Kenton Varda committed
1 2
// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
// Licensed under the MIT License:
3
//
Kenton Varda's avatar
Kenton Varda committed
4 5 6 7 8 9
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
10
//
Kenton Varda's avatar
Kenton Varda committed
11 12
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
13
//
Kenton Varda's avatar
Kenton Varda committed
14 15 16 17 18 19 20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
21 22 23 24

#ifndef KJ_MEMORY_H_
#define KJ_MEMORY_H_

25 26 27 28
#if defined(__GNUC__) && !KJ_HEADER_WARNINGS
#pragma GCC system_header
#endif

29 30 31 32 33
#include "common.h"

namespace kj {

// =======================================================================================
Kenton Varda's avatar
Kenton Varda committed
34
// Disposer -- Implementation details.
35 36

class Disposer {
Kenton Varda's avatar
Kenton Varda committed
37 38 39 40 41 42
  // Abstract interface for a thing that "disposes" of objects, where "disposing" usually means
  // calling the destructor followed by freeing the underlying memory.  `Own<T>` encapsulates an
  // object pointer with corresponding Disposer.
  //
  // Few developers will ever touch this interface.  It is primarily useful for those implementing
  // custom memory allocators.
43 44

protected:
45 46
  // Do not declare a destructor, as doing so will force a global initializer for each HeapDisposer
  // instance.  Eww!
47

Kenton Varda's avatar
Kenton Varda committed
48 49 50 51 52 53
  virtual void disposeImpl(void* pointer) const = 0;
  // Disposes of the object, given a pointer to the beginning of the object.  If the object is
  // polymorphic, this pointer is determined by dynamic_cast<void*>().  For non-polymorphic types,
  // Own<T> does not allow any casting, so the pointer exactly matches the original one given to
  // Own<T>.

54
public:
Kenton Varda's avatar
Kenton Varda committed
55 56 57 58

  template <typename T>
  void dispose(T* object) const;
  // Helper wrapper around disposeImpl().
59
  //
Kenton Varda's avatar
Kenton Varda committed
60
  // If T is polymorphic, calls `disposeImpl(dynamic_cast<void*>(object))`, otherwise calls
61
  // `disposeImpl(implicitCast<void*>(object))`.
62
  //
Kenton Varda's avatar
Kenton Varda committed
63 64 65 66 67 68
  // Callers must not call dispose() on the same pointer twice, even if the first call throws
  // an exception.

private:
  template <typename T, bool polymorphic = __is_polymorphic(T)>
  struct Dispose_;
69 70
};

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
template <typename T>
class DestructorOnlyDisposer: public Disposer {
  // A disposer that merely calls the type's destructor and nothing else.

public:
  static const DestructorOnlyDisposer instance;

  void disposeImpl(void* pointer) const override {
    reinterpret_cast<T*>(pointer)->~T();
  }
};

template <typename T>
const DestructorOnlyDisposer<T> DestructorOnlyDisposer<T>::instance = DestructorOnlyDisposer<T>();

86 87 88 89 90 91 92 93 94
class NullDisposer: public Disposer {
  // A disposer that does nothing.

public:
  static const NullDisposer instance;

  void disposeImpl(void* pointer) const override {}
};

95 96 97 98 99 100 101 102 103 104 105 106
// =======================================================================================
// Own<T> -- An owned pointer.

template <typename T>
class Own {
  // A transferrable title to a T.  When an Own<T> goes out of scope, the object's Disposer is
  // called to dispose of it.  An Own<T> can be efficiently passed by move, without relocating the
  // underlying object; this transfers ownership.
  //
  // This is much like std::unique_ptr, except:
  // - You cannot release().  An owned object is not necessarily allocated with new (see next
  //   point), so it would be hard to use release() correctly.
Kenton Varda's avatar
Kenton Varda committed
107 108 109 110 111 112
  // - The deleter is made polymorphic by virtual call rather than by template.  This is much
  //   more powerful -- it allows the use of custom allocators, freelists, etc.  This could
  //   _almost_ be accomplished with unique_ptr by forcing everyone to use something like
  //   std::unique_ptr<T, kj::Deleter>, except that things get hairy in the presence of multiple
  //   inheritance and upcasting, and anyway if you force everyone to use a custom deleter
  //   then you've lost any benefit to interoperating with the "standard" unique_ptr.
113 114

public:
115 116
  KJ_DISALLOW_COPY(Own);
  inline Own(): disposer(nullptr), ptr(nullptr) {}
117 118
  inline Own(Own&& other) noexcept
      : disposer(other.disposer), ptr(other.ptr) { other.ptr = nullptr; }
119
  inline Own(Own<RemoveConstOrDisable<T>>&& other) noexcept
120
      : disposer(other.disposer), ptr(other.ptr) { other.ptr = nullptr; }
121
  template <typename U, typename = EnableIf<canConvert<U*, T*>()>>
122
  inline Own(Own<U>&& other) noexcept
Kenton Varda's avatar
Kenton Varda committed
123 124 125 126 127 128
      : disposer(other.disposer), ptr(other.ptr) {
    static_assert(__is_polymorphic(T),
        "Casting owned pointers requires that the target type is polymorphic.");
    other.ptr = nullptr;
  }
  inline Own(T* ptr, const Disposer& disposer) noexcept: disposer(&disposer), ptr(ptr) {}
129

130
  ~Own() noexcept(false) { dispose(); }
131 132

  inline Own& operator=(Own&& other) {
133 134 135 136 137 138
    // Move-assingnment operator.

    // Careful, this might own `other`.  Therefore we have to transfer the pointers first, then
    // dispose.
    const Disposer* disposerCopy = disposer;
    T* ptrCopy = ptr;
139 140 141
    disposer = other.disposer;
    ptr = other.ptr;
    other.ptr = nullptr;
142 143 144
    if (ptrCopy != nullptr) {
      disposerCopy->dispose(const_cast<RemoveConst<T>*>(ptrCopy));
    }
145 146 147
    return *this;
  }

148 149 150 151 152
  inline Own& operator=(decltype(nullptr)) {
    dispose();
    return *this;
  }

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
  template <typename U>
  Own<U> downcast() {
    // Downcast the pointer to Own<U>, destroying the original pointer.  If this pointer does not
    // actually point at an instance of U, the results are undefined (throws an exception in debug
    // mode if RTTI is enabled, otherwise you're on your own).

    Own<U> result;
    if (ptr != nullptr) {
      result.ptr = &kj::downcast<U>(*ptr);
      result.disposer = disposer;
      ptr = nullptr;
    }
    return result;
  }

168 169 170 171 172 173
#define NULLCHECK KJ_IREQUIRE(ptr != nullptr, "null Own<> dereference")
  inline T* operator->() { NULLCHECK; return ptr; }
  inline const T* operator->() const { NULLCHECK; return ptr; }
  inline T& operator*() { NULLCHECK; return *ptr; }
  inline const T& operator*() const { NULLCHECK; return *ptr; }
#undef NULLCHECK
174 175 176 177 178 179
  inline T* get() { return ptr; }
  inline const T* get() const { return ptr; }
  inline operator T*() { return ptr; }
  inline operator const T*() const { return ptr; }

private:
Kenton Varda's avatar
Kenton Varda committed
180
  const Disposer* disposer;  // Only valid if ptr != nullptr.
181 182
  T* ptr;

183
  inline explicit Own(decltype(nullptr)): disposer(nullptr), ptr(nullptr) {}
184

185 186 187 188
  inline bool operator==(decltype(nullptr)) { return ptr == nullptr; }
  inline bool operator!=(decltype(nullptr)) { return ptr != nullptr; }
  // Only called by Maybe<Own<T>>.

189 190 191
  inline void dispose() {
    // Make sure that if an exception is thrown, we are left with a null ptr, so we won't possibly
    // dispose again.
Kenton Varda's avatar
Kenton Varda committed
192
    T* ptrCopy = ptr;
193 194
    if (ptrCopy != nullptr) {
      ptr = nullptr;
195
      disposer->dispose(const_cast<RemoveConst<T>*>(ptrCopy));
196 197
    }
  }
198 199 200

  template <typename U>
  friend class Own;
201 202 203
  friend class Maybe<Own<T>>;
};

204
namespace _ {  // private
205 206

template <typename T>
207 208 209 210
class OwnOwn {
public:
  inline OwnOwn(Own<T>&& value) noexcept: value(kj::mv(value)) {}

Kenton Varda's avatar
Kenton Varda committed
211 212 213 214
  inline Own<T>& operator*() & { return value; }
  inline const Own<T>& operator*() const & { return value; }
  inline Own<T>&& operator*() && { return kj::mv(value); }
  inline const Own<T>&& operator*() const && { return kj::mv(value); }
215 216 217 218 219 220 221 222 223 224 225
  inline Own<T>* operator->() { return &value; }
  inline const Own<T>* operator->() const { return &value; }
  inline operator Own<T>*() { return value ? &value : nullptr; }
  inline operator const Own<T>*() const { return value ? &value : nullptr; }

private:
  Own<T> value;
};

template <typename T>
OwnOwn<T> readMaybe(Maybe<Own<T>>&& maybe) { return OwnOwn<T>(kj::mv(maybe.ptr)); }
226
template <typename T>
227
Own<T>* readMaybe(Maybe<Own<T>>& maybe) { return maybe.ptr ? &maybe.ptr : nullptr; }
228
template <typename T>
229
const Own<T>* readMaybe(const Maybe<Own<T>>& maybe) { return maybe.ptr ? &maybe.ptr : nullptr; }
230

231
}  // namespace _ (private)
232 233 234 235 236 237 238 239 240 241

template <typename T>
class Maybe<Own<T>> {
public:
  inline Maybe(): ptr(nullptr) {}
  inline Maybe(Own<T>&& t) noexcept: ptr(kj::mv(t)) {}
  inline Maybe(Maybe&& other) noexcept: ptr(kj::mv(other.ptr)) {}

  template <typename U>
  inline Maybe(Maybe<Own<U>>&& other): ptr(mv(other.ptr)) {}
242 243
  template <typename U>
  inline Maybe(Own<U>&& other): ptr(mv(other)) {}
244 245 246 247 248 249 250 251 252 253 254

  inline Maybe(decltype(nullptr)) noexcept: ptr(nullptr) {}

  inline operator Maybe<T&>() { return ptr.get(); }
  inline operator Maybe<const T&>() const { return ptr.get(); }

  inline Maybe& operator=(Maybe&& other) { ptr = kj::mv(other.ptr); return *this; }

  inline bool operator==(decltype(nullptr)) const { return ptr == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return ptr != nullptr; }

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
  Own<T>& orDefault(Own<T>& defaultValue) {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return ptr;
    }
  }
  const Own<T>& orDefault(const Own<T>& defaultValue) const {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return ptr;
    }
  }

270
  template <typename Func>
271
  auto map(Func&& f) & -> Maybe<decltype(f(instance<Own<T>&>()))> {
272 273 274
    if (ptr == nullptr) {
      return nullptr;
    } else {
275
      return f(ptr);
276 277 278 279
    }
  }

  template <typename Func>
280
  auto map(Func&& f) const & -> Maybe<decltype(f(instance<const Own<T>&>()))> {
281 282 283
    if (ptr == nullptr) {
      return nullptr;
    } else {
284
      return f(ptr);
285 286 287
    }
  }

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
  template <typename Func>
  auto map(Func&& f) && -> Maybe<decltype(f(instance<Own<T>&&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(kj::mv(ptr));
    }
  }

  template <typename Func>
  auto map(Func&& f) const && -> Maybe<decltype(f(instance<const Own<T>&&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(kj::mv(ptr));
    }
  }
305 306 307 308 309 310 311

private:
  Own<T> ptr;

  template <typename U>
  friend class Maybe;
  template <typename U>
312
  friend _::OwnOwn<U> _::readMaybe(Maybe<Own<U>>&& maybe);
313
  template <typename U>
314
  friend Own<U>* _::readMaybe(Maybe<Own<U>>& maybe);
315
  template <typename U>
316
  friend const Own<U>* _::readMaybe(const Maybe<Own<U>>& maybe);
317 318
};

319
namespace _ {  // private
320 321

template <typename T>
Kenton Varda's avatar
Kenton Varda committed
322
class HeapDisposer final: public Disposer {
323
public:
Kenton Varda's avatar
Kenton Varda committed
324
  virtual void disposeImpl(void* pointer) const override { delete reinterpret_cast<T*>(pointer); }
325

Kenton Varda's avatar
Kenton Varda committed
326
  static const HeapDisposer instance;
327 328
};

Kenton Varda's avatar
Kenton Varda committed
329 330 331
template <typename T>
const HeapDisposer<T> HeapDisposer<T>::instance = HeapDisposer<T>();

332
}  // namespace _ (private)
333 334 335 336 337

template <typename T, typename... Params>
Own<T> heap(Params&&... params) {
  // heap<T>(...) allocates a T on the heap, forwarding the parameters to its constructor.  The
  // exact heap implementation is unspecified -- for now it is operator new, but you should not
Kenton Varda's avatar
Kenton Varda committed
338 339
  // assume this.  (Since we know the object size at delete time, we could actually implement an
  // allocator that is more efficient than operator new.)
340

341
  return Own<T>(new T(kj::fwd<Params>(params)...), _::HeapDisposer<T>::instance);
Kenton Varda's avatar
Kenton Varda committed
342 343
}

Kenton Varda's avatar
Kenton Varda committed
344 345 346 347 348 349 350 351
template <typename T>
Own<Decay<T>> heap(T&& orig) {
  // Allocate a copy (or move) of the argument on the heap.
  //
  // The purpose of this overload is to allow you to omit the template parameter as there is only
  // one argument and the purpose is to copy it.

  typedef Decay<T> T2;
352
  return Own<T2>(new T2(kj::fwd<T>(orig)), _::HeapDisposer<T2>::instance);
Kenton Varda's avatar
Kenton Varda committed
353 354
}

355 356 357 358 359 360 361 362 363 364
// =======================================================================================
// SpaceFor<T> -- assists in manual allocation

template <typename T>
class SpaceFor {
  // A class which has the same size and alignment as T but does not call its constructor or
  // destructor automatically.  Instead, call construct() to construct a T in the space, which
  // returns an Own<T> which will take care of calling T's destructor later.

public:
365 366 367
  inline SpaceFor() {}
  inline ~SpaceFor() {}

368 369 370 371 372 373 374 375 376 377 378 379
  template <typename... Params>
  Own<T> construct(Params&&... params) {
    ctor(value, kj::fwd<Params>(params)...);
    return Own<T>(&value, DestructorOnlyDisposer<T>::instance);
  }

private:
  union {
    T value;
  };
};

Kenton Varda's avatar
Kenton Varda committed
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
// =======================================================================================
// Inline implementation details

template <typename T>
struct Disposer::Dispose_<T, true> {
  static void dispose(T* object, const Disposer& disposer) {
    // Note that dynamic_cast<void*> does not require RTTI to be enabled, because the offset to
    // the top of the object is in the vtable -- as it obviously needs to be to correctly implement
    // operator delete.
    disposer.disposeImpl(dynamic_cast<void*>(object));
  }
};
template <typename T>
struct Disposer::Dispose_<T, false> {
  static void dispose(T* object, const Disposer& disposer) {
    disposer.disposeImpl(static_cast<void*>(object));
  }
};

template <typename T>
void Disposer::dispose(T* object) const {
  Dispose_<T>::dispose(object, *this);
402 403 404 405 406
}

}  // namespace kj

#endif  // KJ_MEMORY_H_