diff mbox

[v3] Remove some redundant inline together with constexpr

Message ID 4E441836.6050309@oracle.com
State New
Headers show

Commit Message

Paolo Carlini Aug. 11, 2011, 5:58 p.m. UTC 
Hi,

straightforward (7.1.5/2). Tested x86_64-linux, committed to mainline.

Paolo.

PS: one could also imagine adding a macro like

# ifdef __GXX_EXPERIMENTAL_CXX0X__
#  define _GLIBCXX_INLINE_OR_CONSTEXPR constexpr
# else
#  define _GLIBCXX_INLINE_OR_CONSTEXPR inline
# endif

to be used where now 'inline _GLIBCXX_CONSTEXPR' is used. But I'm not 
sure it's worth it...

//////////////////////
2011-08-11  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/std/future: constexpr functions are implicitly inline.
	* include/std/chrono: Likewise.
	* include/std/complex: Likewise.
	* include/bits/move.h: Likewise.
	* include/bits/stl_pair.h: Likewise.
diff mbox

Patch

Index: include/std/future
===================================================================
--- include/std/future	(revision 177677)
+++ include/std/future	(working copy)
@@ -129,25 +129,25 @@ 
     deferred = 2
   };
 
-  inline constexpr launch operator&(launch __x, launch __y)
+  constexpr launch operator&(launch __x, launch __y)
   {
     return static_cast<launch>(
 	static_cast<int>(__x) & static_cast<int>(__y));
   }
 
-  inline constexpr launch operator|(launch __x, launch __y)
+  constexpr launch operator|(launch __x, launch __y)
   {
     return static_cast<launch>(
 	static_cast<int>(__x) | static_cast<int>(__y));
   }
 
-  inline constexpr launch operator^(launch __x, launch __y)
+  constexpr launch operator^(launch __x, launch __y)
   {
     return static_cast<launch>(
 	static_cast<int>(__x) ^ static_cast<int>(__y));
   }
 
-  inline constexpr launch operator~(launch __x)
+  constexpr launch operator~(launch __x)
   { return static_cast<launch>(~static_cast<int>(__x)); }
 
   inline launch& operator&=(launch& __x, launch __y)
Index: include/std/chrono
===================================================================
--- include/std/chrono	(revision 177677)
+++ include/std/chrono	(working copy)
@@ -168,8 +168,8 @@ 
 
     /// duration_cast
     template<typename _ToDur, typename _Rep, typename _Period>
-      inline constexpr typename enable_if<__is_duration<_ToDur>::value,
-				_ToDur>::type
+      constexpr typename enable_if<__is_duration<_ToDur>::value,
+				   _ToDur>::type
       duration_cast(const duration<_Rep, _Period>& __d)
       {
 	typedef typename _ToDur::period				__to_period;
@@ -352,8 +352,8 @@ 
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr typename common_type<duration<_Rep1, _Period1>,
-					    duration<_Rep2, _Period2>>::type
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+				     duration<_Rep2, _Period2>>::type
       operator+(const duration<_Rep1, _Period1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
       {
@@ -365,8 +365,8 @@ 
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr typename common_type<duration<_Rep1, _Period1>,
-					    duration<_Rep2, _Period2>>::type
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+				     duration<_Rep2, _Period2>>::type
       operator-(const duration<_Rep1, _Period1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
       {
@@ -386,7 +386,7 @@ 
       { typedef typename common_type<_Rep1, _Rep2>::type type; };
 
     template<typename _Rep1, typename _Period, typename _Rep2>
-      inline constexpr
+      constexpr
       duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
       operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
       {
@@ -396,13 +396,13 @@ 
       }
 
     template<typename _Rep1, typename _Period, typename _Rep2>
-      inline constexpr
+      constexpr
       duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
       operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
       { return __d * __s; }
 
     template<typename _Rep1, typename _Period, typename _Rep2>
-      inline constexpr duration<typename __common_rep_type<_Rep1, typename
+      constexpr duration<typename __common_rep_type<_Rep1, typename
 	enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
       operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
       {
@@ -411,9 +411,9 @@ 
 	return __cd(__cd(__d).count() / __s);
       }
 
-     template<typename _Rep1, typename _Period1,
-	      typename _Rep2, typename _Period2>
-      inline constexpr typename common_type<_Rep1, _Rep2>::type
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr typename common_type<_Rep1, _Rep2>::type
       operator/(const duration<_Rep1, _Period1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
       {
@@ -425,7 +425,7 @@ 
 
     // DR 934.
     template<typename _Rep1, typename _Period, typename _Rep2>
-      inline constexpr duration<typename __common_rep_type<_Rep1, typename
+      constexpr duration<typename __common_rep_type<_Rep1, typename
 	enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
       operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
       {
@@ -434,10 +434,10 @@ 
 	return __cd(__cd(__d).count() % __s);
       }
 
-     template<typename _Rep1, typename _Period1,
-	      typename _Rep2, typename _Period2>
-      inline constexpr typename common_type<duration<_Rep1, _Period1>,
-					    duration<_Rep2, _Period2>>::type
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+				     duration<_Rep2, _Period2>>::type
       operator%(const duration<_Rep1, _Period1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
       {
@@ -450,7 +450,7 @@ 
     // comparisons
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr bool
+      constexpr bool
       operator==(const duration<_Rep1, _Period1>& __lhs,
 		 const duration<_Rep2, _Period2>& __rhs)
       {
@@ -462,7 +462,7 @@ 
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr bool
+      constexpr bool
       operator<(const duration<_Rep1, _Period1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
       {
@@ -474,28 +474,28 @@ 
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr bool
+      constexpr bool
       operator!=(const duration<_Rep1, _Period1>& __lhs,
 		 const duration<_Rep2, _Period2>& __rhs)
       { return !(__lhs == __rhs); }
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr bool
+      constexpr bool
       operator<=(const duration<_Rep1, _Period1>& __lhs,
 		 const duration<_Rep2, _Period2>& __rhs)
       { return !(__rhs < __lhs); }
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr bool
+      constexpr bool
       operator>(const duration<_Rep1, _Period1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
       { return __rhs < __lhs; }
 
     template<typename _Rep1, typename _Period1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr bool
+      constexpr bool
       operator>=(const duration<_Rep1, _Period1>& __lhs,
 		 const duration<_Rep2, _Period2>& __rhs)
       { return !(__lhs < __rhs); }
@@ -575,8 +575,8 @@ 
 
     /// time_point_cast
     template<typename _ToDur, typename _Clock, typename _Dur>
-      inline constexpr typename enable_if<__is_duration<_ToDur>::value,
-				time_point<_Clock, _ToDur>>::type
+      constexpr typename enable_if<__is_duration<_ToDur>::value,
+				   time_point<_Clock, _ToDur>>::type
       time_point_cast(const time_point<_Clock, _Dur>& __t)
       {
 	typedef time_point<_Clock, _ToDur> 			__time_point;
@@ -585,7 +585,7 @@ 
 
     template<typename _Clock, typename _Dur1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr time_point<_Clock,
+      constexpr time_point<_Clock,
 	typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
       operator+(const time_point<_Clock, _Dur1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
@@ -598,7 +598,7 @@ 
 
     template<typename _Rep1, typename _Period1,
 	     typename _Clock, typename _Dur2>
-      inline constexpr time_point<_Clock,
+      constexpr time_point<_Clock,
 	typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
       operator+(const duration<_Rep1, _Period1>& __lhs,
 		const time_point<_Clock, _Dur2>& __rhs)
@@ -611,7 +611,7 @@ 
 
     template<typename _Clock, typename _Dur1,
 	     typename _Rep2, typename _Period2>
-      inline constexpr time_point<_Clock,
+      constexpr time_point<_Clock,
 	typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
       operator-(const time_point<_Clock, _Dur1>& __lhs,
 		const duration<_Rep2, _Period2>& __rhs)
@@ -623,43 +623,43 @@ 
       }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr typename common_type<_Dur1, _Dur2>::type
+      constexpr typename common_type<_Dur1, _Dur2>::type
       operator-(const time_point<_Clock, _Dur1>& __lhs,
 		const time_point<_Clock, _Dur2>& __rhs)
       { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr bool
+      constexpr bool
       operator==(const time_point<_Clock, _Dur1>& __lhs,
 		 const time_point<_Clock, _Dur2>& __rhs)
       { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr bool
+      constexpr bool
       operator!=(const time_point<_Clock, _Dur1>& __lhs,
 		 const time_point<_Clock, _Dur2>& __rhs)
       { return !(__lhs == __rhs); }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr bool
+      constexpr bool
       operator<(const time_point<_Clock, _Dur1>& __lhs,
 		const time_point<_Clock, _Dur2>& __rhs)
       { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr bool
+      constexpr bool
       operator<=(const time_point<_Clock, _Dur1>& __lhs,
 		 const time_point<_Clock, _Dur2>& __rhs)
       { return !(__rhs < __lhs); }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr bool
+      constexpr bool
       operator>(const time_point<_Clock, _Dur1>& __lhs,
 		const time_point<_Clock, _Dur2>& __rhs)
       { return __rhs < __lhs; }
 
     template<typename _Clock, typename _Dur1, typename _Dur2>
-      inline constexpr bool
+      constexpr bool
       operator>=(const time_point<_Clock, _Dur1>& __lhs,
 		 const time_point<_Clock, _Dur2>& __rhs)
       { return !(__lhs < __rhs); }
Index: include/std/complex
===================================================================
--- include/std/complex	(revision 177677)
+++ include/std/complex	(working copy)
@@ -531,12 +531,12 @@ 
   // Values
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
   template<typename _Tp>
-    inline constexpr _Tp
+    constexpr _Tp
     real(const complex<_Tp>& __z)
     { return __z.real(); }
-    
+
   template<typename _Tp>
-    inline constexpr _Tp
+    constexpr _Tp
     imag(const complex<_Tp>& __z)
     { return __z.imag(); }
 #else
Index: include/bits/move.h
===================================================================
--- include/bits/move.h	(revision 177677)
+++ include/bits/move.h	(working copy)
@@ -58,12 +58,12 @@ 
   
   /// forward (as per N3143)
   template<typename _Tp>
-    inline constexpr _Tp&&
+    constexpr _Tp&&
     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
     { return static_cast<_Tp&&>(__t); }
 
   template<typename _Tp>
-    inline constexpr _Tp&&
+    constexpr _Tp&&
     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
     {
       static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
@@ -78,7 +78,7 @@ 
    *  @return Same, moved.
   */
   template<typename _Tp>
-    inline constexpr typename std::remove_reference<_Tp>::type&&
+    constexpr typename std::remove_reference<_Tp>::type&&
     move(_Tp&& __t) noexcept
     { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
 
Index: include/bits/stl_pair.h
===================================================================
--- include/bits/stl_pair.h	(revision 177677)
+++ include/bits/stl_pair.h	(working copy)
@@ -275,8 +275,8 @@ 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
   // NB: DR 706.
   template<class _T1, class _T2>
-    inline constexpr pair<typename __decay_and_strip<_T1>::__type,
-			  typename __decay_and_strip<_T2>::__type>
+    constexpr pair<typename __decay_and_strip<_T1>::__type,
+                   typename __decay_and_strip<_T2>::__type>
     make_pair(_T1&& __x, _T2&& __y)
     {
       typedef typename __decay_and_strip<_T1>::__type __ds_type1;