[Boost-commit] svn:boost r65584 - sandbox/opaque/boost/opaque

Subject: [Boost-commit] svn:boost r65584 - sandbox/opaque/boost/opaque
From: vicente.botet_at_[hidden]
Date: 2010-09-24 17:40:49

Author: viboes
Date: 2010-09-24 17:40:45 EDT (Fri, 24 Sep 2010)
New Revision: 65584
URL: http://svn.boost.org/trac/boost/changeset/65584

Log:
Opaque: Split operators on single operators and combined operators
Added:
   sandbox/opaque/boost/opaque/combined_operators.hpp   (contents, props changed)
Text files modified: 
   sandbox/opaque/boost/opaque/opaque_type.hpp |     2 +-                                      
   sandbox/opaque/boost/opaque/operators.hpp   |     4 ++--                                    
   2 files changed, 3 insertions(+), 3 deletions(-)

Added: sandbox/opaque/boost/opaque/combined_operators.hpp
==============================================================================
--- (empty file)
+++ sandbox/opaque/boost/opaque/combined_operators.hpp	2010-09-24 17:40:45 EDT (Fri, 24 Sep 2010)
@@ -0,0 +1,223 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2010.
+// Distributed under the Boost
+// Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/opaque for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_OPAQUE_COMBINED_OPERATORS_HPP
+#define BOOST_OPAQUE_COMBINED_OPERATORS_HPP
+
+#include <boost/opaque/new_type.hpp>
+#include <boost/operators.hpp>
+#include <boost/opaque/operators.hpp>
+
+namespace boost {
+
+namespace opaque {
+    
+    template <typename Final, typename Base=base_new_type>
+    struct equality_comparable1 : boost::equality_comparable1<Final, ope::equal<Final, Base> > {};
+        
+    template <typename Final, typename Base=base_new_type>
+    struct less_than_comparable1 : boost::less_than_comparable1<Final, ope::less_than<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct addable1 : boost::addable1<Final, ope::plus_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct subtractable1 : boost::subtractable1<Final, ope::minus_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct multipliable1 : boost::multipliable1<Final, ope::multiply_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct dividable1 : boost::dividable1<Final, ope::divide_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct modable1 : boost::modable1<Final, ope::modulus_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct xorable1 : boost::xorable1<Final, ope::bitwise_xor_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct andable1 : boost::andable1<Final, ope::bitwise_and_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct orable1 : boost::orable1<Final, ope::bitwise_or_assign<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct incrementable : boost::incrementable<Final, ope::pre_increment<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct decrementable : boost::decrementable<Final, ope::pre_decrement<Final, Base> > {};
+
+    //~ template <typename Final, typename Base=base_new_type>
+    //~ struct left_shiftable : boost::left_shiftable<Final, ope::left_shift<Final, Base> > {};
+
+    //~ template <typename Final, typename Base=base_new_type>
+    //~ struct right_shiftable : boost::right_shiftable<Final, ope::right_shift<Final, Base> > {};
+
+    template <typename Final, typename Base=base_new_type>
+    struct partially_ordered1 : boost::less_than_comparable1<Final, ope::less_than<Final, Base> > {};
+
+
+    template <class T, class B = base_new_type >
+    struct totally_ordered1
+        : opaque::less_than_comparable1<T
+        , opaque::equality_comparable1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct additive2
+        //~ : opaque::addable2<T, U
+        //~ , opaque::subtractable2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct additive1
+        : opaque::addable1<T
+        , opaque::subtractable1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct multiplicative2
+        //~ : opaque::multipliable2<T, U
+        //~ , opaque::dividable2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct multiplicative1
+        : opaque::multipliable1<T
+        , opaque::dividable1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct integer_multiplicative2
+        //~ : opaque::multiplicative2<T, U
+        //~ , opaque::modable2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct integer_multiplicative1
+        : opaque::multiplicative1<T
+        , opaque::modable1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct arithmetic2
+        //~ : opaque::additive2<T, U
+        //~ , opaque::multiplicative2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct arithmetic1
+        : opaque::additive1<T
+        , opaque::multiplicative1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct integer_arithmetic2
+        //~ : additive2<T, U
+        //~ , integer_multiplicative2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct integer_arithmetic1
+        : opaque::additive1<T
+        , opaque::integer_multiplicative1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct bitwise2
+        //~ : opaque::xorable2<T, U
+        //~ , opaque::andable2<T, U
+        //~ , opaque::orable2<T, U, B
+          //~ > > > {};
+
+    template <class T, class B = base_new_type >
+    struct bitwise1
+        : opaque::xorable1<T
+        , opaque::andable1<T
+        , opaque::orable1<T, B
+          > > > {};
+
+    template <class T, class B = base_new_type >
+    struct unit_steppable
+        : opaque::incrementable<T
+        , opaque::decrementable<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct shiftable2
+        //~ : opaque::left_shiftable2<T, U
+        //~ , opaque::right_shiftable2<T, U, B
+          //~ > > {};
+
+    //~ template <class T, class B = base_new_type >
+    //~ struct shiftable1
+        //~ : opaque::left_shiftable1<T
+        //~ , opaque::right_shiftable1<T, B
+          //~ > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct ring_operators2
+        //~ : opaque::additive2<T, U
+        //~ , opaque::subtractable2_left<T, U
+        //~ , opaque::multipliable2<T, U, B
+          //~ > > > {};
+
+    template <class T, class B = base_new_type >
+    struct ring_operators1
+        : opaque::additive1<T
+        , opaque::multipliable1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct ordered_ring_operators2
+        //~ : opaque::ring_operators2<T, U
+        //~ , opaque::totally_ordered2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct ordered_ring_operators1
+        : opaque::ring_operators1<T
+        , opaque::totally_ordered1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct field_operators2
+        //~ : opaque::ring_operators2<T, U
+        //~ , opaque::dividable2<T, U
+        //~ , opaque::dividable2_left<T, U, B
+          //~ > > > {};
+
+    template <class T, class B = base_new_type >
+    struct field_operators1
+        : opaque::ring_operators1<T
+        , opaque::dividable1<T, B
+          > > {};
+
+    //~ template <class T, class U, class B = base_new_type >
+    //~ struct ordered_field_operators2
+        //~ : opaque::field_operators2<T, U
+        //~ , opaque::totally_ordered2<T, U, B
+          //~ > > {};
+
+    template <class T, class B = base_new_type >
+    struct ordered_field_operators1
+        : opaque::field_operators1<T
+        , opaque::totally_ordered1<T, B
+          > > {};
+
+
+}
+}
+
+
+#endif

Modified: sandbox/opaque/boost/opaque/opaque_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/opaque_type.hpp	(original)
+++ sandbox/opaque/boost/opaque/opaque_type.hpp	2010-09-24 17:40:45 EDT (Fri, 24 Sep 2010)
@@ -14,7 +14,7 @@
 #define BOOST_OPAQUE_OPAQUE_TYPE_HPP
 
 #include <boost/opaque/new_type.hpp>
-#include <boost/opaque/operators.hpp>
+#include <boost/opaque/combined_operators.hpp>
 
 namespace boost {    
 

Modified: sandbox/opaque/boost/opaque/operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/operators.hpp	2010-09-24 17:40:45 EDT (Fri, 24 Sep 2010)
@@ -203,7 +203,7 @@
     };
     
 }
-    
+#if 0    
     template <typename Final, typename Base=base_new_type>
     struct equality_comparable1 : boost::equality_comparable1<Final, ope::equal<Final, Base> > {};
         
@@ -233,7 +233,7 @@
 
     template <typename Final, typename Base=base_new_type>
     struct orable1 : boost::orable1<Final, ope::bitwise_or_assign<Final, Base> > {};
-
+#endif
 
 }
 }