--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkUniquePtr_DEFINED
+#define SkUniquePtr_DEFINED
+
+#include "SkTLogic.h"
+#include "SkUtility.h"
+
+namespace skstd {
+
+template <typename T> struct default_delete {
+ /*constexpr*/ default_delete() /*noexcept*/ = default;
+
+ template <typename U, typename = enable_if_t<is_convertible<U*, T*>::value>>
+ default_delete(const default_delete<U>&) /*noexcept*/ {}
+
+ void operator()(T* obj) const {
+ static_assert(sizeof(T) > 0, "Deleting pointer to incomplete type!");
+ delete obj;
+ }
+};
+template <typename T> struct default_delete<T[]> {
+ /*constexpr*/ default_delete() /*noexcept*/ = default;
+
+ void operator()(T* obj) const {
+ static_assert(sizeof(T) > 0, "Deleting pointer to incomplete type!");
+ delete [] obj;
+ }
+};
+
+template <typename T, typename D = default_delete<T>> class unique_ptr {
+ // remove_reference_t<D>::pointer if that type exists, otherwise T*.
+ struct pointer_type_detector {
+ template <typename U> static typename U::pointer detector(typename U::pointer*);
+ template <typename U> static T* detector(...);
+ using type = decltype(detector<remove_reference_t<D>>(0));
+ };
+
+public:
+ using pointer = typename pointer_type_detector::type;
+ using element_type = T;
+ using deleter_type = D;
+
+private:
+ template <typename B, bool = is_empty<B>::value /*&& !is_final<B>::value*/>
+ struct compressed_base : private B {
+ /*constexpr*/ compressed_base() : B() {}
+ /*constexpr*/ compressed_base(const B& b) : B(b) {}
+ /*constexpr*/ compressed_base(const B&& b) : B(move(b)) {}
+ /*constexpr*/ B& get() /*noexcept*/ { return *this; }
+ /*constexpr*/ B const& get() const /*noexcept*/ { return *this; }
+ void swap(compressed_base&) /*noexcept*/ { }
+ };
+
+ template <typename B> struct compressed_base<B, false> {
+ B fb;
+ /*constexpr*/ compressed_base() : B() {}
+ /*constexpr*/ compressed_base(const B& b) : fb(b) {}
+ /*constexpr*/ compressed_base(const B&& b) : fb(move(b)) {}
+ /*constexpr*/ B& get() /*noexcept*/ { return fb; }
+ /*constexpr*/ B const& get() const /*noexcept*/ { return fb; }
+ void swap(compressed_base& that) /*noexcept*/ { SkTSwap(fb, that.fB); }
+ };
+
+ struct compressed_data : private compressed_base<deleter_type> {
+ pointer fPtr;
+ /*constexpr*/ compressed_data() : compressed_base<deleter_type>(), fPtr() {}
+ /*constexpr*/ compressed_data(const pointer& ptr, const deleter_type& d)
+ : compressed_base<deleter_type>(d), fPtr(ptr) {}
+ template <typename U1, typename U2, typename = enable_if_t<
+ is_convertible<U1, pointer>::value && is_convertible<U2, deleter_type>::value
+ >> /*constexpr*/ compressed_data(U1&& ptr, U2&& d)
+ : compressed_base<deleter_type>(skstd::forward<U2>(d)), fPtr(skstd::forward<U1>(ptr)) {}
+ /*constexpr*/ pointer& getPointer() /*noexcept*/ { return fPtr; }
+ /*constexpr*/ pointer const& getPointer() const /*noexcept*/ { return fPtr; }
+ /*constexpr*/ deleter_type& getDeleter() /*noexcept*/ {
+ return compressed_base<deleter_type>::get();
+ }
+ /*constexpr*/ deleter_type const& getDeleter() const /*noexcept*/ {
+ return compressed_base<deleter_type>::get();
+ }
+ void swap(compressed_data& that) /*noexcept*/ {
+ compressed_base<deleter_type>::swap(static_cast<compressed_base<deleter_type>>(that));
+ SkTSwap(fPtr, that.fPtr);
+ }
+ };
+ compressed_data data;
+
+public:
+ /*constexpr*/ unique_ptr() /*noexcept*/ : data() {
+ static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
+ }
+
+ /*constexpr*/ unique_ptr(skstd::nullptr_t) /*noexcept*/ : unique_ptr() { }
+
+ explicit unique_ptr(pointer ptr) /*noexcept*/ : data(ptr, deleter_type()) {
+ static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
+ }
+
+ unique_ptr(pointer ptr,
+ conditional_t<is_reference<deleter_type>::value, deleter_type,const deleter_type&> d)
+ /*noexcept*/ : data(ptr, d)
+ {}
+
+ unique_ptr(pointer ptr, remove_reference_t<deleter_type>&& d) /*noexcept*/
+ : data(move(ptr), move(d))
+ {
+ static_assert(!is_reference<deleter_type>::value,
+ "Binding an rvalue reference deleter as an lvalue reference deleter is not allowed.");
+ }
+
+
+ unique_ptr(unique_ptr&& that) /*noexcept*/
+ : data(that.release(), forward<deleter_type>(that.get_deleter()))
+ {}
+
+ template <typename U, typename ThatD, typename = enable_if_t<
+ is_convertible<typename unique_ptr<U, ThatD>::pointer, pointer>::value &&
+ !is_array<U>::value &&
+ conditional_t<is_reference<D>::value, is_same<ThatD, D>, is_convertible<ThatD, D>>::value>>
+ unique_ptr(unique_ptr<U, ThatD>&& that) /*noexcept*/
+ : data(that.release(), forward<ThatD>(that.get_deleter()))
+ {}
+
+ ~unique_ptr() /*noexcept*/ {
+ pointer& ptr = data.getPointer();
+ if (ptr != nullptr) {
+ get_deleter()(ptr);
+ }
+ ptr = pointer();
+ }
+
+ unique_ptr& operator=(unique_ptr&& that) /*noexcept*/ {
+ reset(that.release());
+ get_deleter() = forward<deleter_type>(that.get_deleter());
+ return *this;
+ }
+
+ template <typename U, typename ThatD> enable_if_t<
+ is_convertible<typename unique_ptr<U, ThatD>::pointer, pointer>::value &&
+ !is_array<U>::value,
+ unique_ptr&> operator=(unique_ptr<U, ThatD>&& that) /*noexcept*/ {
+ reset(that.release());
+ get_deleter() = forward<ThatD>(that.get_deleter());
+ return *this;
+ }
+
+ unique_ptr& operator=(skstd::nullptr_t) /*noexcept*/ {
+ reset();
+ return *this;
+ }
+
+ add_lvalue_reference_t<element_type> operator*() const {
+ SkASSERT(get() != pointer());
+ return *get();
+ }
+
+ pointer operator->() const /*noexcept*/ {
+ SkASSERT(get() != pointer());
+ return get();
+ }
+
+ pointer get() const /*noexcept*/ {
+ return data.getPointer();
+ }
+
+ deleter_type& get_deleter() /*noexcept*/ {
+ return data.getDeleter();
+ }
+
+ const deleter_type& get_deleter() const /*noexcept*/ {
+ return data.getDeleter();
+ }
+
+ //explicit operator bool() const noexcept {
+ bool is_attached() const /*noexcept*/ {
+ return get() == pointer() ? false : true;
+ }
+
+ pointer release() /*noexcept*/ {
+ pointer ptr = get();
+ data.getPointer() = pointer();
+ return ptr;
+ }
+
+ void reset(pointer ptr = pointer()) /*noexcept*/ {
+ SkTSwap(data.getPointer(), ptr);
+ if (ptr != pointer()) {
+ get_deleter()(ptr);
+ }
+ }
+
+ void swap(unique_ptr& that) /*noexcept*/ {
+ SkTSwap(data, that.data);
+ }
+
+ unique_ptr(const unique_ptr&) = delete;
+ unique_ptr& operator=(const unique_ptr&) = delete;
+};
+
+template <typename T, typename D> class unique_ptr<T[], D> {
+ // remove_reference_t<D>::pointer if that type exists, otherwise T*.
+ struct pointer_type_detector {
+ template <typename U> static typename U::pointer detector(typename U::pointer*);
+ template <typename U> static T* detector(...);
+ using type = decltype(detector<remove_reference_t<D>>(0));
+ };
+
+public:
+ using pointer = typename pointer_type_detector::type;
+ using element_type = T;
+ using deleter_type = D;
+
+private:
+ template <typename B, bool = is_empty<B>::value /*&& !is_final<B>::value*/>
+ struct compressed_base : private B {
+ /*constexpr*/ compressed_base() : B() {}
+ /*constexpr*/ compressed_base(const B& b) : B(b) {}
+ /*constexpr*/ compressed_base(const B&& b) : B(move(b)) {}
+ /*constexpr*/ B& get() /*noexcept*/ { return *this; }
+ /*constexpr*/ B const& get() const /*noexcept*/ { return *this; }
+ void swap(compressed_base&) /*noexcept*/ { }
+ };
+
+ template <typename B> struct compressed_base<B, false> {
+ B fb;
+ /*constexpr*/ compressed_base() : B() {}
+ /*constexpr*/ compressed_base(const B& b) : fb(b) {}
+ /*constexpr*/ compressed_base(const B&& b) : fb(move(b)) {}
+ /*constexpr*/ B& get() /*noexcept*/ { return fb; }
+ /*constexpr*/ B const& get() const /*noexcept*/ { return fb; }
+ void swap(compressed_base& that) /*noexcept*/ { SkTSwap(fb, that.fB); }
+ };
+
+ struct compressed_data : private compressed_base<deleter_type> {
+ pointer fPtr;
+ /*constexpr*/ compressed_data() : compressed_base<deleter_type>(), fPtr() {}
+ /*constexpr*/ compressed_data(const pointer& ptr, const deleter_type& d)
+ : compressed_base<deleter_type>(d), fPtr(ptr) {}
+ template <typename U1, typename U2, typename = enable_if_t<
+ is_convertible<U1, pointer>::value && is_convertible<U2, deleter_type>::value
+ >> /*constexpr*/ compressed_data(U1&& ptr, U2&& d)
+ : compressed_base<deleter_type>(skstd::forward<U2>(d)), fPtr(skstd::forward<U1>(ptr)) {}
+ /*constexpr*/ pointer& getPointer() /*noexcept*/ { return fPtr; }
+ /*constexpr*/ pointer const& getPointer() const /*noexcept*/ { return fPtr; }
+ /*constexpr*/ deleter_type& getDeleter() /*noexcept*/ {
+ return compressed_base<deleter_type>::get();
+ }
+ /*constexpr*/ deleter_type const& getDeleter() const /*noexcept*/ {
+ return compressed_base<deleter_type>::get();
+ }
+ void swap(compressed_data& that) /*noexcept*/ {
+ compressed_base<deleter_type>::swap(static_cast<compressed_base<deleter_type>>(that));
+ SkTSwap(fPtr, that.fPtr);
+ }
+ };
+ compressed_data data;
+
+public:
+ /*constexpr*/ unique_ptr() /*noexcept*/ : data() {
+ static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
+ }
+
+ /*constexpr*/ unique_ptr(skstd::nullptr_t) /*noexcept*/ : unique_ptr() { }
+
+ explicit unique_ptr(pointer ptr) /*noexcept*/ : data(ptr, deleter_type()) {
+ static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
+ }
+
+ unique_ptr(pointer ptr,
+ conditional_t<is_reference<deleter_type>::value, deleter_type,const deleter_type&> d)
+ /*noexcept*/ : data(ptr, d)
+ {}
+
+ unique_ptr(pointer ptr, remove_reference_t<deleter_type>&& d) /*noexcept*/
+ : data(move(ptr), move(d))
+ {
+ static_assert(!is_reference<deleter_type>::value,
+ "Binding an rvalue reference deleter as an lvalue reference deleter is not allowed.");
+ }
+
+ unique_ptr(unique_ptr&& that) /*noexcept*/
+ : data(that.release(), forward<deleter_type>(that.get_deleter()))
+ {}
+
+ ~unique_ptr() {
+ pointer& ptr = data.getPointer();
+ if (ptr != nullptr) {
+ get_deleter()(ptr);
+ }
+ ptr = pointer();
+ }
+
+ unique_ptr& operator=(unique_ptr&& that) /*noexcept*/ {
+ reset(that.release());
+ get_deleter() = forward<deleter_type>(that.get_deleter());
+ return *this;
+ }
+
+ unique_ptr& operator=(skstd::nullptr_t) /*noexcept*/ {
+ reset();
+ return *this;
+ }
+
+ add_lvalue_reference_t<element_type> operator[](size_t i) const {
+ SkASSERT(get() != pointer());
+ return get()[i];
+ }
+
+ pointer get() const /*noexcept*/ {
+ return data.getPointer();
+ }
+
+ deleter_type& get_deleter() /*noexcept*/ {
+ return data.getDeleter();
+ }
+
+ const deleter_type& get_deleter() const /*noexcept*/ {
+ return data.getDeleter();
+ }
+
+ //explicit operator bool() const noexcept {
+ bool is_attached() const /*noexcept*/ {
+ return get() == pointer() ? false : true;
+ }
+
+ pointer release() /*noexcept*/ {
+ pointer ptr = get();
+ data.getPointer() = pointer();
+ return ptr;
+ }
+
+ void reset(pointer ptr = pointer()) /*noexcept*/ {
+ SkTSwap(data.getPointer(), ptr);
+ if (ptr != pointer()) {
+ get_deleter()(ptr);
+ }
+ }
+
+ template <typename U> void reset(U*) = delete;
+
+ void swap(unique_ptr& that) /*noexcept*/ {
+ data.swap(that.data);
+ }
+
+ unique_ptr(const unique_ptr&) = delete;
+ unique_ptr& operator=(const unique_ptr&) = delete;
+};
+
+template <typename T, typename D>
+inline void swap(unique_ptr<T, D>& a, unique_ptr<T, D>& b) /*noexcept*/ {
+ a.swap(b);
+}
+
+template <typename T, typename D, typename U, typename ThatD>
+inline bool operator==(const unique_ptr<T, D>& a, const unique_ptr<U, ThatD>& b) {
+ return a.get() == b.get();
+}
+
+template <typename T, typename D>
+inline bool operator==(const unique_ptr<T, D>& a, skstd::nullptr_t) /*noexcept*/ {
+ //return !a;
+ return !a.is_attached();
+}
+
+template <typename T, typename D>
+inline bool operator==(skstd::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
+ //return !b;
+ return !b.is_attached();
+}
+
+template <typename T, typename D, typename U, typename ThatD>
+inline bool operator!=(const unique_ptr<T, D>& a, const unique_ptr<U, ThatD>& b) {
+ return a.get() != b.get();
+}
+
+template <typename T, typename D>
+inline bool operator!=(const unique_ptr<T, D>& a, skstd::nullptr_t) /*noexcept*/ {
+ //return (bool)a;
+ return a.is_attached();
+}
+
+template <typename T, typename D>
+inline bool operator!=(skstd::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
+ //return (bool)b;
+ return b.is_attached();
+}
+
+} // namespace skstd
+
+#endif
Moveable src1; Moveable dst1(skstd::move(src1));
Moveable src2, dst2; dst2 = skstd::move(src2);
}
+
+#define TOO_BIG "The unique_ptr was bigger than expected."
+#define WEIRD_SIZE "The unique_ptr was a different size than expected."
+
+DEF_TEST(CPlusPlusEleven_UniquePtr, r) {
+ struct SmallUniquePtr {
+ Moveable* p;
+ };
+ struct BigUniquePtr {
+ void(*d)(Moveable*);
+ Moveable* p;
+ };
+
+ static_assert(sizeof(skstd::unique_ptr<Moveable>) == sizeof(SmallUniquePtr), TOO_BIG);
+ static_assert(sizeof(skstd::unique_ptr<Moveable[]>) == sizeof(SmallUniquePtr), TOO_BIG);
+
+ using proc = void(*)(Moveable*);
+ static_assert(sizeof(skstd::unique_ptr<Moveable, proc>) == sizeof(BigUniquePtr), WEIRD_SIZE);
+ static_assert(sizeof(skstd::unique_ptr<Moveable[], proc>) == sizeof(BigUniquePtr), WEIRD_SIZE);
+
+ {
+ skstd::unique_ptr<Moveable, void(*)(Moveable*)> u(nullptr, deleter<Moveable>);
+ static_assert(sizeof(u) == sizeof(BigUniquePtr), WEIRD_SIZE);
+
+ auto u2 = skstd::move(u);
+ static_assert(sizeof(u2) == sizeof(BigUniquePtr), WEIRD_SIZE);
+ }
+
+ {
+ skstd::unique_ptr<Moveable, void(*)(Moveable*)> u(nullptr, [](Moveable* m){ deleter(m); });
+ static_assert(sizeof(u) == sizeof(BigUniquePtr), WEIRD_SIZE);
+
+ auto u2 = skstd::move(u);
+ static_assert(sizeof(u2) == sizeof(BigUniquePtr), WEIRD_SIZE);
+ }
+
+ {
+ auto d = [](Moveable* m){ deleter(m); };
+ skstd::unique_ptr<Moveable, decltype(d)> u(nullptr, d);
+ static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+ auto u2 = skstd::move(u);
+ static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+ }
+
+ {
+ skstd::unique_ptr<Moveable, Deleter<Moveable>> u(nullptr, Deleter<Moveable>());
+ static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+ auto u2 = skstd::move(u);
+ static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+ }
+
+ {
+ skstd::unique_ptr<Moveable, Deleter<Moveable>> u(new Moveable(), Deleter<Moveable>());
+ static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+ auto u2 = skstd::move(u);
+ static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+ }
+
+ {
+ skstd::unique_ptr<const void, Deleter<const void>> u(new Moveable(), Deleter<const void>());
+ static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+ auto u2 = skstd::move(u);
+ static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+ }
+}
projects / platform / upstream / libSkiaSharp.git / commitdiff