Remove uses of boost::enable_if_

pdimov · pdimov · commit f2abcf16545b · 2024-10-06T19:16:42.000+03:00
diff --git a/include/boost/smart_ptr/allocate_local_shared_array.hpp b/include/boost/smart_ptr/allocate_local_shared_array.hpp
@@ -10,6 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/smart_ptr/allocate_shared_array.hpp>
 #include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <type_traits>
 
 namespace boost {
 namespace detail {
@@ -69,7 +70,7 @@ class lsp_size_array_state
 } /* detail */
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator, std::size_t count)
 {
@@ -89,7 +90,7 @@ allocate_local_shared(const A& allocator, std::size_t count)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator)
 {
@@ -112,7 +113,7 @@ allocate_local_shared(const A& allocator)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator, std::size_t count,
     const typename remove_extent<T>::type& value)
@@ -133,7 +134,7 @@ allocate_local_shared(const A& allocator, std::size_t count,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator,
     const typename remove_extent<T>::type& value)
@@ -157,7 +158,7 @@ allocate_local_shared(const A& allocator,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared_noinit(const A& allocator, std::size_t count)
 {
@@ -166,7 +167,7 @@ allocate_local_shared_noinit(const A& allocator, std::size_t count)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared_noinit(const A& allocator)
 {
diff --git a/include/boost/smart_ptr/allocate_shared_array.hpp b/include/boost/smart_ptr/allocate_shared_array.hpp
@@ -12,7 +12,6 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/alloc_construct.hpp>
 #include <boost/core/first_scalar.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/extent.hpp>
 #include <boost/type_traits/is_bounded_array.hpp>
 #include <boost/type_traits/is_unbounded_array.hpp>
@@ -258,7 +257,7 @@ struct sp_array_result {
 } /* detail */
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator, std::size_t count)
 {
     typedef typename detail::sp_array_element<T>::type element;
@@ -275,7 +274,7 @@ allocate_shared(const A& allocator, std::size_t count)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator)
 {
     enum {
@@ -295,7 +294,7 @@ allocate_shared(const A& allocator)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator, std::size_t count,
     const typename remove_extent<T>::type& value)
 {
@@ -313,7 +312,7 @@ allocate_shared(const A& allocator, std::size_t count,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator,
     const typename remove_extent<T>::type& value)
 {
@@ -334,14 +333,14 @@ allocate_shared(const A& allocator,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared_noinit(const A& allocator, std::size_t count)
 {
     return boost::allocate_shared<T>(boost::noinit_adapt(allocator), count);
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared_noinit(const A& allocator)
 {
     return boost::allocate_shared<T>(boost::noinit_adapt(allocator));
diff --git a/include/boost/smart_ptr/allocate_unique.hpp b/include/boost/smart_ptr/allocate_unique.hpp
@@ -14,7 +14,6 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/first_scalar.hpp>
 #include <boost/core/noinit_adaptor.hpp>
 #include <boost/core/pointer_traits.hpp>
-#include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/extent.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_bounded_array.hpp>
@@ -26,6 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <memory>
 #include <utility>
 #include <cstddef>
+#include <type_traits>
 
 namespace boost {
 namespace detail {
@@ -354,7 +354,7 @@ class sp_alloc_make {
 } /* detail */
 
 template<class T, class A>
-inline typename enable_if_<!is_array<T>::value,
+inline typename std::enable_if<!is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc)
 {
@@ -364,7 +364,7 @@ allocate_unique(const A& alloc)
 }
 
 template<class T, class A, class... Args>
-inline typename enable_if_<!is_array<T>::value,
+inline typename std::enable_if<!is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc, Args&&... args)
 {
@@ -374,7 +374,7 @@ allocate_unique(const A& alloc, Args&&... args)
 }
 
 template<class T, class A>
-inline typename enable_if_<!is_array<T>::value,
+inline typename std::enable_if<!is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc, typename type_identity<T>::type&& value)
 {
@@ -384,15 +384,15 @@ allocate_unique(const A& alloc, typename type_identity<T>::type&& value)
 }
 
 template<class T, class A>
-inline typename enable_if_<!is_array<T>::value,
+inline typename std::enable_if<!is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
 allocate_unique_noinit(const A& alloc)
 {
     return boost::allocate_unique<T, noinit_adaptor<A> >(alloc);
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc, std::size_t size)
 {
@@ -403,7 +403,7 @@ allocate_unique(const A& alloc, std::size_t size)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     std::unique_ptr<typename detail::sp_alloc_result<T>::type,
         alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc)
@@ -415,15 +415,15 @@ allocate_unique(const A& alloc)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
 allocate_unique_noinit(const A& alloc, std::size_t size)
 {
     return boost::allocate_unique<T, noinit_adaptor<A> >(alloc, size);
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     std::unique_ptr<typename detail::sp_alloc_result<T>::type,
         alloc_deleter<T, noinit_adaptor<A> > > >::type
 allocate_unique_noinit(const A& alloc)
@@ -432,7 +432,7 @@ allocate_unique_noinit(const A& alloc)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc, std::size_t size,
     const typename remove_extent<T>::type& value)
@@ -445,7 +445,7 @@ allocate_unique(const A& alloc, std::size_t size,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     std::unique_ptr<typename detail::sp_alloc_result<T>::type,
         alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc,
diff --git a/include/boost/smart_ptr/make_local_shared_array.hpp b/include/boost/smart_ptr/make_local_shared_array.hpp
@@ -11,11 +11,12 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/core/default_allocator.hpp>
 #include <boost/smart_ptr/allocate_local_shared_array.hpp>
+#include <type_traits>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared()
 {
@@ -24,7 +25,7 @@ make_local_shared()
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared(const typename remove_extent<T>::type& value)
 {
@@ -33,7 +34,7 @@ make_local_shared(const typename remove_extent<T>::type& value)
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared(std::size_t size)
 {
@@ -42,7 +43,7 @@ make_local_shared(std::size_t size)
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared(std::size_t size,
     const typename remove_extent<T>::type& value)
@@ -52,7 +53,7 @@ make_local_shared(std::size_t size,
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared_noinit()
 {
@@ -61,7 +62,7 @@ make_local_shared_noinit()
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared_noinit(std::size_t size)
 {
diff --git a/include/boost/smart_ptr/make_shared_array.hpp b/include/boost/smart_ptr/make_shared_array.hpp
@@ -10,51 +10,52 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/core/default_allocator.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
+#include <type_traits>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared()
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>());
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared(const typename remove_extent<T>::type& value)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), value);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared(std::size_t size)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), size);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared(std::size_t size, const typename remove_extent<T>::type& value)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), size, value);
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit()
 {
     return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>());
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit(std::size_t size)
 {
     return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
diff --git a/include/boost/smart_ptr/make_unique.hpp b/include/boost/smart_ptr/make_unique.hpp

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ Distributed under the Boost Software License, Version 1.0.`
`10`	`10`
`11`	`11`	`#include <boost/smart_ptr/allocate_shared_array.hpp>`
`12`	`12`	`#include <boost/smart_ptr/local_shared_ptr.hpp>`
	`13`	`+#include <type_traits>`
`13`	`14`
`14`	`15`	`namespace boost {`
`15`	`16`	`namespace detail {`
`@@ -69,7 +70,7 @@ class lsp_size_array_state`
`69`	`70`	`} /* detail */`
`70`	`71`
`71`	`72`	`template<class T, class A>`
`72`		`-inline typename enable_if_<is_unbounded_array<T>::value,`
	`73`	`+inline typename std::enable_if<is_unbounded_array<T>::value,`
`73`	`74`	`local_shared_ptr<T> >::type`
`74`	`75`	`allocate_local_shared(const A& allocator, std::size_t count)`
`75`	`76`	`{`
`@@ -89,7 +90,7 @@ allocate_local_shared(const A& allocator, std::size_t count)`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`template<class T, class A>`
`92`		`-inline typename enable_if_<is_bounded_array<T>::value,`
	`93`	`+inline typename std::enable_if<is_bounded_array<T>::value,`
`93`	`94`	`local_shared_ptr<T> >::type`
`94`	`95`	`allocate_local_shared(const A& allocator)`
`95`	`96`	`{`
`@@ -112,7 +113,7 @@ allocate_local_shared(const A& allocator)`
`112`	`113`	`}`
`113`	`114`
`114`	`115`	`template<class T, class A>`
`115`		`-inline typename enable_if_<is_unbounded_array<T>::value,`
	`116`	`+inline typename std::enable_if<is_unbounded_array<T>::value,`
`116`	`117`	`local_shared_ptr<T> >::type`
`117`	`118`	`allocate_local_shared(const A& allocator, std::size_t count,`
`118`	`119`	`const typename remove_extent<T>::type& value)`
`@@ -133,7 +134,7 @@ allocate_local_shared(const A& allocator, std::size_t count,`
`133`	`134`	`}`
`134`	`135`
`135`	`136`	`template<class T, class A>`
`136`		`-inline typename enable_if_<is_bounded_array<T>::value,`
	`137`	`+inline typename std::enable_if<is_bounded_array<T>::value,`
`137`	`138`	`local_shared_ptr<T> >::type`
`138`	`139`	`allocate_local_shared(const A& allocator,`
`139`	`140`	`const typename remove_extent<T>::type& value)`
`@@ -157,7 +158,7 @@ allocate_local_shared(const A& allocator,`
`157`	`158`	`}`
`158`	`159`
`159`	`160`	`template<class T, class A>`
`160`		`-inline typename enable_if_<is_unbounded_array<T>::value,`
	`161`	`+inline typename std::enable_if<is_unbounded_array<T>::value,`
`161`	`162`	`local_shared_ptr<T> >::type`
`162`	`163`	`allocate_local_shared_noinit(const A& allocator, std::size_t count)`
`163`	`164`	`{`
`@@ -166,7 +167,7 @@ allocate_local_shared_noinit(const A& allocator, std::size_t count)`
`166`	`167`	`}`
`167`	`168`
`168`	`169`	`template<class T, class A>`
`169`		`-inline typename enable_if_<is_bounded_array<T>::value,`
	`170`	`+inline typename std::enable_if<is_bounded_array<T>::value,`
`170`	`171`	`local_shared_ptr<T> >::type`
`171`	`172`	`allocate_local_shared_noinit(const A& allocator)`
`172`	`173`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@ Distributed under the Boost Software License, Version 1.0.`
`12`	`12`	`#include <boost/core/alloc_construct.hpp>`
`13`	`13`	`#include <boost/core/first_scalar.hpp>`
`14`	`14`	`#include <boost/smart_ptr/shared_ptr.hpp>`
`15`		`-#include <boost/type_traits/enable_if.hpp>`
`16`	`15`	`#include <boost/type_traits/extent.hpp>`
`17`	`16`	`#include <boost/type_traits/is_bounded_array.hpp>`
`18`	`17`	`#include <boost/type_traits/is_unbounded_array.hpp>`
`@@ -258,7 +257,7 @@ struct sp_array_result {`
`258`	`257`	`} /* detail */`
`259`	`258`
`260`	`259`	`template<class T, class A>`
`261`		`-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type`
	`260`	`+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type`
`262`	`261`	`allocate_shared(const A& allocator, std::size_t count)`
`263`	`262`	`{`
`264`	`263`	`typedef typename detail::sp_array_element<T>::type element;`
`@@ -275,7 +274,7 @@ allocate_shared(const A& allocator, std::size_t count)`
`275`	`274`	`}`
`276`	`275`
`277`	`276`	`template<class T, class A>`
`278`		`-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type`
	`277`	`+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type`
`279`	`278`	`allocate_shared(const A& allocator)`
`280`	`279`	`{`
`281`	`280`	`enum {`
`@@ -295,7 +294,7 @@ allocate_shared(const A& allocator)`
`295`	`294`	`}`
`296`	`295`
`297`	`296`	`template<class T, class A>`
`298`		`-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type`
	`297`	`+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type`
`299`	`298`	`allocate_shared(const A& allocator, std::size_t count,`
`300`	`299`	`const typename remove_extent<T>::type& value)`
`301`	`300`	`{`
`@@ -313,7 +312,7 @@ allocate_shared(const A& allocator, std::size_t count,`
`313`	`312`	`}`
`314`	`313`
`315`	`314`	`template<class T, class A>`
`316`		`-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type`
	`315`	`+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type`
`317`	`316`	`allocate_shared(const A& allocator,`
`318`	`317`	`const typename remove_extent<T>::type& value)`
`319`	`318`	`{`
`@@ -334,14 +333,14 @@ allocate_shared(const A& allocator,`
`334`	`333`	`}`
`335`	`334`
`336`	`335`	`template<class T, class A>`
`337`		`-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type`
	`336`	`+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type`
`338`	`337`	`allocate_shared_noinit(const A& allocator, std::size_t count)`
`339`	`338`	`{`
`340`	`339`	`return boost::allocate_shared<T>(boost::noinit_adapt(allocator), count);`
`341`	`340`	`}`
`342`	`341`
`343`	`342`	`template<class T, class A>`
`344`		`-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type`
	`343`	`+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type`
`345`	`344`	`allocate_shared_noinit(const A& allocator)`
`346`	`345`	`{`
`347`	`346`	`return boost::allocate_shared<T>(boost::noinit_adapt(allocator));`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,12 @@ Distributed under the Boost Software License, Version 1.0.`
`11`	`11`
`12`	`12`	`#include <boost/core/default_allocator.hpp>`
`13`	`13`	`#include <boost/smart_ptr/allocate_local_shared_array.hpp>`
	`14`	`+#include <type_traits>`
`14`	`15`
`15`	`16`	`namespace boost {`
`16`	`17`
`17`	`18`	`template<class T>`
`18`		`-inline typename enable_if_<is_bounded_array<T>::value,`
	`19`	`+inline typename std::enable_if<is_bounded_array<T>::value,`
`19`	`20`	`local_shared_ptr<T> >::type`
`20`	`21`	`make_local_shared()`
`21`	`22`	`{`
`@@ -24,7 +25,7 @@ make_local_shared()`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`template<class T>`
`27`		`-inline typename enable_if_<is_bounded_array<T>::value,`
	`28`	`+inline typename std::enable_if<is_bounded_array<T>::value,`
`28`	`29`	`local_shared_ptr<T> >::type`
`29`	`30`	`make_local_shared(const typename remove_extent<T>::type& value)`
`30`	`31`	`{`
`@@ -33,7 +34,7 @@ make_local_shared(const typename remove_extent<T>::type& value)`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`template<class T>`
`36`		`-inline typename enable_if_<is_unbounded_array<T>::value,`
	`37`	`+inline typename std::enable_if<is_unbounded_array<T>::value,`
`37`	`38`	`local_shared_ptr<T> >::type`
`38`	`39`	`make_local_shared(std::size_t size)`
`39`	`40`	`{`
`@@ -42,7 +43,7 @@ make_local_shared(std::size_t size)`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`template<class T>`
`45`		`-inline typename enable_if_<is_unbounded_array<T>::value,`
	`46`	`+inline typename std::enable_if<is_unbounded_array<T>::value,`
`46`	`47`	`local_shared_ptr<T> >::type`
`47`	`48`	`make_local_shared(std::size_t size,`
`48`	`49`	`const typename remove_extent<T>::type& value)`
`@@ -52,7 +53,7 @@ make_local_shared(std::size_t size,`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`template<class T>`
`55`		`-inline typename enable_if_<is_bounded_array<T>::value,`
	`56`	`+inline typename std::enable_if<is_bounded_array<T>::value,`
`56`	`57`	`local_shared_ptr<T> >::type`
`57`	`58`	`make_local_shared_noinit()`
`58`	`59`	`{`
`@@ -61,7 +62,7 @@ make_local_shared_noinit()`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`template<class T>`
`64`		`-inline typename enable_if_<is_unbounded_array<T>::value,`
	`65`	`+inline typename std::enable_if<is_unbounded_array<T>::value,`
`65`	`66`	`local_shared_ptr<T> >::type`
`66`	`67`	`make_local_shared_noinit(std::size_t size)`
`67`	`68`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,51 +10,52 @@ Distributed under the Boost Software License, Version 1.0.`
`10`	`10`
`11`	`11`	`#include <boost/core/default_allocator.hpp>`
`12`	`12`	`#include <boost/smart_ptr/allocate_shared_array.hpp>`
	`13`	`+#include <type_traits>`
`13`	`14`
`14`	`15`	`namespace boost {`
`15`	`16`
`16`	`17`	`template<class T>`
`17`		`-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type`
	`18`	`+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type`
`18`	`19`	`make_shared()`
`19`	`20`	`{`
`20`	`21`	`return boost::allocate_shared<T>(boost::default_allocator<typename`
`21`	`22`	`detail::sp_array_element<T>::type>());`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`template<class T>`
`25`		`-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type`
	`26`	`+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type`
`26`	`27`	`make_shared(const typename remove_extent<T>::type& value)`
`27`	`28`	`{`
`28`	`29`	`return boost::allocate_shared<T>(boost::default_allocator<typename`
`29`	`30`	`detail::sp_array_element<T>::type>(), value);`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`template<class T>`
`33`		`-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type`
	`34`	`+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type`
`34`	`35`	`make_shared(std::size_t size)`
`35`	`36`	`{`
`36`	`37`	`return boost::allocate_shared<T>(boost::default_allocator<typename`
`37`	`38`	`detail::sp_array_element<T>::type>(), size);`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`template<class T>`
`41`		`-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type`
	`42`	`+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type`
`42`	`43`	`make_shared(std::size_t size, const typename remove_extent<T>::type& value)`
`43`	`44`	`{`
`44`	`45`	`return boost::allocate_shared<T>(boost::default_allocator<typename`
`45`	`46`	`detail::sp_array_element<T>::type>(), size, value);`
`46`	`47`	`}`
`47`	`48`
`48`	`49`	`template<class T>`
`49`		`-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type`
	`50`	`+inline typename std::enable_if<is_bounded_array<T>::value, shared_ptr<T> >::type`
`50`	`51`	`make_shared_noinit()`
`51`	`52`	`{`
`52`	`53`	`return boost::allocate_shared_noinit<T>(boost::default_allocator<typename`
`53`	`54`	`detail::sp_array_element<T>::type>());`
`54`	`55`	`}`
`55`	`56`
`56`	`57`	`template<class T>`
`57`		`-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type`
	`58`	`+inline typename std::enable_if<is_unbounded_array<T>::value, shared_ptr<T> >::type`
`58`	`59`	`make_shared_noinit(std::size_t size)`
`59`	`60`	`{`
`60`	`61`	`return boost::allocate_shared_noinit<T>(boost::default_allocator<typename`