[NFC] remove trailing WS

[hiraditya]

Closed by commit: rL311283

include/memory

 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
 
 // pointer_traits
 
 template <class _Tp, class = void>
 struct __has_element_type : false_type {};
 
 template <class _Tp>
-struct __has_element_type<_Tp, 
+struct __has_element_type<_Tp,
               typename __void_t<typename _Tp::element_type>::type> : true_type {};
 
 template <class _Ptr, bool = __has_element_type<_Ptr>::value>
 struct __pointer_traits_element_type;
 
 template <class _Ptr>
 struct __pointer_traits_element_type<_Ptr, true>
 {
     typedef typename _Ptr::element_type type;
 };

 {
     typedef _Tp type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Tp, class = void>
 struct __has_difference_type : false_type {};
 
 template <class _Tp>
-struct __has_difference_type<_Tp, 
+struct __has_difference_type<_Tp,
             typename __void_t<typename _Tp::difference_type>::type> : true_type {};
 
 template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
 struct __pointer_traits_difference_type
 {
     typedef ptrdiff_t type;
 };
 
 template <class _Ptr>
 struct __pointer_traits_difference_type<_Ptr, true>

     typedef typename pointer_traits<_From>::template rebind<_To>::other type;
 #endif
 };
 
 // allocator_traits
 
 template <class _Tp, class = void>
 struct __has_pointer_type : false_type {};
 
 template <class _Tp>
-struct __has_pointer_type<_Tp, 
+struct __has_pointer_type<_Tp,
           typename __void_t<typename _Tp::pointer>::type> : true_type {};
 
 namespace __pointer_type_imp
 {
 
 template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value>
 struct __pointer_type
 {
     typedef typename _Dp::pointer type;
 };

 template <class _Tp, class _Dp>
 struct __pointer_type
 {
     typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type;
 };
 
 template <class _Tp, class = void>
 struct __has_const_pointer : false_type {};
 
 template <class _Tp>
-struct __has_const_pointer<_Tp, 
+struct __has_const_pointer<_Tp,
             typename __void_t<typename _Tp::const_pointer>::type> : true_type {};
 
 template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
 struct __const_pointer
 {
     typedef typename _Alloc::const_pointer type;
 };
 
 template <class _Tp, class _Ptr, class _Alloc>
 struct __const_pointer<_Tp, _Ptr, _Alloc, false>

     typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type;
 #endif
 };
 
 template <class _Tp, class = void>
 struct __has_void_pointer : false_type {};
 
 template <class _Tp>
-struct __has_void_pointer<_Tp, 
+struct __has_void_pointer<_Tp,
                typename __void_t<typename _Tp::void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
 struct __void_pointer
 {
     typedef typename _Alloc::void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __void_pointer<_Ptr, _Alloc, false>

     typedef typename pointer_traits<_Ptr>::template rebind<void> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<void>::other type;
 #endif
 };
 
 template <class _Tp, class = void>
 struct __has_const_void_pointer : false_type {};
 
 template <class _Tp>
-struct __has_const_void_pointer<_Tp, 
+struct __has_const_void_pointer<_Tp,
             typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
 struct __const_void_pointer
 {
     typedef typename _Alloc::const_void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __const_void_pointer<_Ptr, _Alloc, false>

 template <class _Alloc>
 struct __propagate_on_container_copy_assignment<_Alloc, true>
 {
     typedef typename _Alloc::propagate_on_container_copy_assignment type;
 };
 
 template <class _Tp, class = void>
 struct __has_propagate_on_container_move_assignment : false_type {};
 
 template <class _Tp>
-struct __has_propagate_on_container_move_assignment<_Tp, 
+struct __has_propagate_on_container_move_assignment<_Tp,
            typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type>
                : true_type {};
 
 template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
 struct __propagate_on_container_move_assignment
 {
     typedef false_type type;
 };
 
 template <class _Alloc>
 struct __propagate_on_container_move_assignment<_Alloc, true>
 {
     typedef typename _Alloc::propagate_on_container_move_assignment type;
 };
 
 template <class _Tp, class = void>
 struct __has_propagate_on_container_swap : false_type {};
 
 template <class _Tp>
-struct __has_propagate_on_container_swap<_Tp, 
+struct __has_propagate_on_container_swap<_Tp,
            typename __void_t<typename _Tp::propagate_on_container_swap>::type>
                : true_type {};
 
 template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
 struct __propagate_on_container_swap
 {
     typedef false_type type;
 };
 
 template <class _Alloc>
 struct __propagate_on_container_swap<_Alloc, true>
 {
     typedef typename _Alloc::propagate_on_container_swap type;
 };
 
 template <class _Tp, class = void>
 struct __has_is_always_equal : false_type {};
 
 template <class _Tp>
-struct __has_is_always_equal<_Tp, 
+struct __has_is_always_equal<_Tp,
            typename __void_t<typename _Tp::is_always_equal>::type>
                : true_type {};
 
 template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
 struct __is_always_equal
 {
     typedef typename _VSTD::is_empty<_Alloc>::type type;
 };
 
 template <class _Alloc>

     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element)
         {::new(&*__x_) _Tp(__element); return *this;}
 #if _LIBCPP_STD_VER >= 14
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element)
         {::new(&*__x_) _Tp(_VSTD::move(__element)); return *this;}
 #endif
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator  operator++(int)
         {raw_storage_iterator __t(*this); ++__x_; return __t;}
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; } 
+    _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; }
 #endif
 };
 
 template <class _Tp>
 pair<_Tp*, ptrdiff_t>
 get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
 {
     pair<_Tp*, ptrdiff_t> __r(0, 0);
     const ptrdiff_t __m = (~ptrdiff_t(0) ^
                            ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))

     _LIBCPP_INLINE_VISIBILITY
     bool
     __owner_equivalent(const shared_ptr& __p) const
         {return __cntrl_ == __p.__cntrl_;}
 
 #ifndef _LIBCPP_NO_RTTI
     template <class _Dp>
         _LIBCPP_INLINE_VISIBILITY
         _Dp* __get_deleter() const _NOEXCEPT
             {return static_cast<_Dp*>(__cntrl_
-                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp))) 
+                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
                       : nullptr);}
 #endif  // _LIBCPP_NO_RTTI
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template<class ..._Args>
         static
         shared_ptr<_Tp>
         make_shared(_Args&& ...__args);
 

     return *this;
 }
 #endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 inline
 typename enable_if
 <
     !is_array<_Yp>::value &&
-    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 
+    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
                    typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     return *this;
 }
 #endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Yp>::value &&
-    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 
+    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
                    typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_load(const shared_ptr<_Tp>* __p)
 {
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     shared_ptr<_Tp> __q = *__p;
     __m.unlock();
     return __q;
 }
-  
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
 {
     return atomic_load(__p);
 }
 
 template <class _Tp>

 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 {
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     __p->swap(__r);
     __m.unlock();
     return __r;
 }
-  
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
 {
     return atomic_exchange(__p, __r);
 }
 
 template <class _Tp>

 // --- Helper for container swap --
 template <typename _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
-    __swap_allocator(__a1, __a2, 
+    __swap_allocator(__a1, __a2,
       integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
 template <typename _Alloc>
 _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)

 {
     using _VSTD::swap;
     swap(__a1, __a2);
 }
 
 template <typename _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool, 
+struct __noexcept_move_assign_container : public integral_constant<bool,
     _Traits::propagate_on_container_move_assignment::value
 #if _LIBCPP_STD_VER > 14
         || _Traits::is_always_equal::value
 #else
         && is_nothrow_move_assignable<_Alloc>::value
 #endif
     > {};
 
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
-    
     typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v;
     _Alloc &__a;
 
     _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
     _Tp &   get() { return *__addr(); }
-        
     template<class... _Args>
     __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc)
     { _Traits::construct(__a, __addr(), _VSTD::forward<_Args>(__args)...); }
-    
     ~__temp_value() { _Traits::destroy(__a, __addr()); }
     };
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_MEMORY