Start using <type_traits> and <utility> (C++11).

include/private/SkUniquePtr.h

 /*
  * 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"
+#include <cstddef>
+#include <utility>
 
 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 {
@@ skipping 21 matching lines @@
 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*/ compressed_base(B&& b) : B(std::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*/ compressed_base(B&& b) : fb(std::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)) {}
+            : compressed_base<deleter_type>(std::forward<U2>(d)), fPtr(std::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() { }
+    /*constexpr*/ unique_ptr(std::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))
+        : data(std::move(ptr), std::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()))
+        : data(that.release(), std::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()))
+        : data(that.release(), std::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());
+        get_deleter() = std::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());
+        get_deleter() = std::forward<ThatD>(that.get_deleter());
         return *this;
     }
 
-    unique_ptr& operator=(skstd::nullptr_t) /*noexcept*/ {
+    unique_ptr& operator=(std::nullptr_t) /*noexcept*/ {
         reset();
         return *this;
     }
 
     add_lvalue_reference_t<element_type> operator*() const {
         SkASSERT(get() != pointer());
         return *get();
     }
 
     pointer operator->() const /*noexcept*/ {
@@ skipping 50 matching lines @@
 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*/ compressed_base(B&& b) : B(std::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*/ compressed_base(B&& b) : fb(std::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)) {}
+            : compressed_base<deleter_type>(std::forward<U2>(d)), fPtr(std::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() { }
+    /*constexpr*/ unique_ptr(std::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))
+        : data(std::move(ptr), std::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()))
+        : data(that.release(), std::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());
+        get_deleter() = std::forward<deleter_type>(that.get_deleter());
         return *this;
     }
 
-    unique_ptr& operator=(skstd::nullptr_t) /*noexcept*/ {
+    unique_ptr& operator=(std::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*/ {
@@ skipping 40 matching lines @@
 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*/ {
+inline bool operator==(const unique_ptr<T, D>& a, std::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*/ {
+inline bool operator==(std::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*/ {
+inline bool operator!=(const unique_ptr<T, D>& a, std::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*/ {
+inline bool operator!=(std::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
     //return (bool)b;
     return b.is_attached();
 }
 
 }  // namespace skstd
 
 #endif