More <type_traits> for SkTLogic.h.

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
 
@@ skipping 76 matching lines @@
         }
         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!");
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
     }
 
     /*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!");
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
     }
 
     unique_ptr(pointer ptr,
-               conditional_t<is_reference<deleter_type>::value, deleter_type,const deleter_type&> d)
+               conditional_t<std::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(std::move(ptr), std::move(d))
     {
-        static_assert(!is_reference<deleter_type>::value,
+        static_assert(!std::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(), 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>>
+        !std::is_array<U>::value &&
+        conditional_t<std::is_reference<D>::value,
+                      std::is_same<ThatD, D>,
+                      is_convertible<ThatD, D>>::value>>
     unique_ptr(unique_ptr<U, ThatD>&& that) /*noexcept*/
         : 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() = 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,
+        !std::is_array<U>::value,
     unique_ptr&> operator=(unique_ptr<U, ThatD>&& that) /*noexcept*/ {
         reset(that.release());
         get_deleter() = std::forward<ThatD>(that.get_deleter());
         return *this;
     }
 
     unique_ptr& operator=(std::nullptr_t) /*noexcept*/ {
         reset();
         return *this;
     }
@@ skipping 99 matching lines @@
         }
         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!");
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
     }
 
     /*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!");
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
     }
 
     unique_ptr(pointer ptr,
-               conditional_t<is_reference<deleter_type>::value, deleter_type,const deleter_type&> d)
+               conditional_t<std::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(std::move(ptr), std::move(d))
     {
-        static_assert(!is_reference<deleter_type>::value,
+        static_assert(!std::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(), std::forward<deleter_type>(that.get_deleter()))
     {}
 
     ~unique_ptr() {
         pointer& ptr = data.getPointer();
         if (ptr != nullptr) {
@@ skipping 93 matching lines @@
 
 template <typename T, typename D>
 inline bool operator!=(std::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
     //return (bool)b;
     return b.is_attached();
 }
 
 }  // namespace skstd
 
 #endif