chrono (duration<>::operator%=, operator%): Add, per DR 934.

2009-07-21  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/std/chrono (duration<>::operator%=,  operator%):
	Add, per DR 934.
	* testsuite/20_util/duration/arithmetic/dr934-1.cc: New.
	* testsuite/20_util/duration/arithmetic/dr934-2.cc: Likewise.

	* include/std/chrono (operator/): Simplify implementation.

From-SVN: r149856

4 files changed, 175 insertions, 42 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 3d706ca..84e1edc 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,12 @@
+2009-07-21  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	* include/std/chrono (duration<>::operator%=,  operator%):
+	Add, per DR 934.
+	* testsuite/20_util/duration/arithmetic/dr934-1.cc: New.
+	* testsuite/20_util/duration/arithmetic/dr934-2.cc: Likewise.
+
+	* include/std/chrono (operator/): Simplify implementation.
+
 2009-07-20  Benjamin Kosnik  <bkoz@redhat.com>
 
 	* doc/xml/manual/intro.xml: Escape '&', validate.
diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
index d18f277..aa4888d 100644
--- a/libstdc++-v3/include/std/chrono
+++ b/libstdc++-v3/include/std/chrono
@@ -154,7 +154,7 @@ namespace std
 
     /// treat_as_floating_point
     template<typename _Rep>
-      struct treat_as_floating_point 
+      struct treat_as_floating_point
       : is_floating_point<_Rep>
       { };
 
@@ -211,7 +211,7 @@ namespace std
 	duration() = default;
 
         template<typename _Rep2>
-          explicit duration(_Rep2 const& __rep)
+          explicit duration(const _Rep2& __rep)
           : __r(static_cast<rep>(__rep))
           {
             static_assert(is_convertible<_Rep2,rep>::value 
@@ -244,29 +244,29 @@ namespace std
         { return *this; }
 
         duration
-        operator-() const 
+        operator-() const
         { return duration(-__r); }
 
         duration&
-        operator++() 
+        operator++()
         {
           ++__r;
           return *this;
         }
 
         duration
-        operator++(int) 
+        operator++(int)
         { return duration(__r++); }
 
         duration&
-        operator--() 
-        { 
+        operator--()
+        {
           --__r;
           return *this;
         }
 
         duration
-        operator--(int) 
+        operator--(int)
         { return duration(__r--); }
         
         duration&
@@ -292,11 +292,30 @@ namespace std
 
         duration&
         operator/=(const rep& __rhs)
-        { 
+        {
           __r /= __rhs;
           return *this;
         }
 
+	// DR 934.
+	template<typename _Rep2 = rep>
+	  typename enable_if<!treat_as_floating_point<_Rep2>::value,
+			     duration&>::type
+	  operator%=(const rep& __rhs)
+	  {
+	    __r %= __rhs;
+	    return *this;
+	  }
+
+	template<typename _Rep2 = rep>
+	  typename enable_if<!treat_as_floating_point<_Rep2>::value,
+			     duration&>::type
+	  operator%=(const duration& __d)
+	  {
+	    __r %= __d.count();
+	    return *this;
+	  }
+
         // 20.8.3.4 special values
         // TODO: These should be constexprs.
         static const duration
@@ -310,8 +329,8 @@ namespace std
         static const duration
         max()
         { return duration(duration_values<rep>::max()); }
-   
-      private:    
+
+      private:
         rep __r;
       };
 
@@ -351,46 +370,49 @@ namespace std
       inline duration<typename common_type<_Rep1, _Rep2>::type, _Period>
       operator*(const _Rep2& __s, const duration<_Rep1, _Period>& __d)
       { return __d * __s; }
-
-    template<typename _Tp, typename _Up, typename _Ep = void>
-      struct __division_impl;
-  
+ 
     template<typename _Rep1, typename _Period, typename _Rep2>
-      struct __division_impl<duration<_Rep1, _Period>, _Rep2, 
-        typename enable_if<!__is_duration<_Rep2>::value>::type>
+      inline duration<typename common_type<_Rep1, typename
+	enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
+      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
       {
-        typedef typename common_type<_Rep1, _Rep2>::type __cr;
-        typedef 
-          duration<typename common_type<_Rep1, _Rep2>::type, _Period> __rt;
-
-        static __rt
-        __divide(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-        { return duration<__cr, _Period>(__d) /= __s; }
-      };
+	typedef typename common_type<_Rep1, _Rep2>::type __cr;
+	return duration<__cr, _Period>(__d) /= __s;
+      }
 
-    template<typename _Rep1, typename _Period1, 
-             typename _Rep2, typename _Period2>
-      struct __division_impl<duration<_Rep1, _Period1>, 
-                             duration<_Rep2, _Period2>>
+     template<typename _Rep1, typename _Period1,
+	      typename _Rep2, typename _Period2>
+      inline typename common_type<_Rep1, _Rep2>::type
+      operator/(const duration<_Rep1, _Period1>& __lhs, 
+                const duration<_Rep2, _Period2>& __rhs)
       {
         typedef typename common_type<duration<_Rep1, _Period1>, 
                                      duration<_Rep2, _Period2>>::type __ct;
-        typedef typename common_type<_Rep1, _Rep2>::type __rt;
+        return __ct(__lhs).count() / __ct(__rhs).count();
+      }
 
-        static __rt
-        __divide(const duration<_Rep1, _Period1>& __lhs, 
-                 const duration<_Rep2, _Period2>& __rhs)
-        { return __ct(__lhs).count() / __ct(__rhs).count(); }
-      };
-  
-    template<typename _Rep, typename _Period, typename _Up>
-      inline typename __division_impl<duration<_Rep, _Period>, _Up>::__rt
-      operator/(const duration<_Rep, _Period>& __d, const _Up& __u)
+    // DR 934.
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      inline duration<typename common_type<_Rep1, typename
+	enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
+      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
       {
-        return 
-          __division_impl<duration<_Rep, _Period>, _Up>::__divide(__d, __u);
+	typedef typename common_type<_Rep1, _Rep2>::type __cr;
+	return duration<__cr, _Period>(__d) %= __s;
       }
- 
+
+     template<typename _Rep1, typename _Period1,
+	      typename _Rep2, typename _Period2>
+      inline typename common_type<duration<_Rep1, _Period1>, 
+                                  duration<_Rep2, _Period2>>::type
+      operator%(const duration<_Rep1, _Period1>& __lhs, 
+                const duration<_Rep2, _Period2>& __rhs)
+      {
+        typedef typename common_type<duration<_Rep1, _Period1>, 
+                                     duration<_Rep2, _Period2>>::type __ct;
+        return __ct(__lhs) %= __rhs;
+      }
+
     // comparisons
     template<typename _Rep1, typename _Period1,
              typename _Rep2, typename _Period2>
diff --git a/libstdc++-v3/testsuite/20_util/duration/arithmetic/dr934-1.cc b/libstdc++-v3/testsuite/20_util/duration/arithmetic/dr934-1.cc
new file mode 100644
index 0000000..decf94c
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/duration/arithmetic/dr934-1.cc
@@ -0,0 +1,48 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+// { dg-require-cstdint "" }
+
+// Copyright (C) 2009 Free Software Foundation
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <chrono>
+
+class ClockTime
+{
+  typedef std::chrono::hours hours;
+  typedef std::chrono::minutes minutes;
+  typedef std::chrono::seconds seconds;
+
+public:
+  hours hours_;
+  minutes minutes_;
+  seconds seconds_;
+
+  template<typename Rep, typename Period>
+    explicit
+    ClockTime(const std::chrono::duration<Rep, Period>& d)
+    : hours_  (std::chrono::duration_cast<hours>  (d)),
+      minutes_(std::chrono::duration_cast<minutes>(d % hours(1))),
+      seconds_(std::chrono::duration_cast<seconds>(d % minutes(1))) { }
+};
+
+// DR 934.
+void test01()
+{
+  std::chrono::duration<int> d;
+  ClockTime ct(d);
+}
diff --git a/libstdc++-v3/testsuite/20_util/duration/arithmetic/dr934-2.cc b/libstdc++-v3/testsuite/20_util/duration/arithmetic/dr934-2.cc
new file mode 100644
index 0000000..ada8ba5
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/duration/arithmetic/dr934-2.cc
@@ -0,0 +1,54 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-require-cstdint "" }
+
+// Copyright (C) 2009 Free Software Foundation
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <chrono>
+#include <testsuite_hooks.h>
+
+// DR 934.
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std::chrono;
+
+  const duration<int> d0(17);
+  duration<int> d3(d0);
+  d3 %= 5;
+  VERIFY( d3.count() == 2 );
+
+  const duration<int> d4(7);
+  duration<int> d5(d0);
+  d5 %= d4;
+  VERIFY( d5.count() == 3 );
+
+  const duration<int> d6 = d0 % 6;
+  VERIFY( d6.count() == 5 );
+
+  const duration<int> d7(11);
+  const duration<int> d8 = d0 % d7;
+  VERIFY( d8.count() == 6 );
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}