|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65733 - in sandbox/opaque/boost/opaque: . meta_mixin
From: vicente.botet_at_[hidden]
Date: 2010-10-03 04:45:43
Author: viboes
Date: 2010-10-03 04:45:42 EDT (Sun, 03 Oct 2010)
New Revision: 65733
URL: http://svn.boost.org/trac/boost/changeset/65733
Log:
Opaque:
* Cleanup
Text files modified:
sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp | 77 ++++++++++++++++++++
sandbox/opaque/boost/opaque/meta_mixin/operators.hpp | 150 +++++++++++++++++++++++++++++++--------
sandbox/opaque/boost/opaque/new_class.hpp | 15 +++
sandbox/opaque/boost/opaque/new_type.hpp | 13 ++
4 files changed, 216 insertions(+), 39 deletions(-)
Modified: sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp (original)
+++ sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp 2010-10-03 04:45:42 EDT (Sun, 03 Oct 2010)
@@ -19,6 +19,8 @@
namespace boost {
namespace opaque {
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool) \
BOOST_OPAQUE_USING_EQUAL(Final,Bool) \
BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool)
@@ -31,6 +33,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool) \
BOOST_OPAQUE_USING_LESS_THAN(Final,Bool) \
BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool) \
@@ -45,6 +49,7 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
#define BOOST_OPAQUE_ADDABLE1(Final) \
BOOST_OPAQUE_USING_PLUS_ASSIGN(Final) \
@@ -57,6 +62,7 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
#define BOOST_OPAQUE_SUBTRACTABLE1(Final) \
BOOST_OPAQUE_USING_MINUS_ASSIGN(Final) \
@@ -69,6 +75,7 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
#define BOOST_OPAQUE_MULTIPLIABLE1(Final) \
BOOST_OPAQUE_USING_MULTIPLY_ASSIGN(Final) \
@@ -81,6 +88,7 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
#define BOOST_OPAQUE_DIVIDABLE1(Final) \
BOOST_OPAQUE_USING_DIVIDE_ASSIGN(Final) \
@@ -93,6 +101,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_MODABLE1(Final) \
BOOST_OPAQUE_USING_MODULUS_ASSIGN(Final) \
BOOST_OPAQUE_USING_MODULUS(Final)
@@ -104,6 +114,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_BITWISE_XORABLE1(Final) \
BOOST_OPAQUE_USING_BITWISE_XOR_ASSIGN(Final) \
BOOST_OPAQUE_USING_BITWISE_XOR(Final)
@@ -115,6 +127,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_BITWISE_ANDABLE1(Final) \
BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final) \
BOOST_OPAQUE_USING_BITWISE_AND(Final)
@@ -126,6 +140,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_BITWISE_ORABLE1(Final) \
BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
BOOST_OPAQUE_USING_BITWISE_OR(Final)
@@ -137,6 +153,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_INCREMENTABLE(Final) \
BOOST_OPAQUE_USING_PRE_INCREMENT(Final) \
BOOST_OPAQUE_USING_POST_INCREMENT(Final)
@@ -149,6 +167,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_DECREMENTABLE(Final) \
BOOST_OPAQUE_USING_PRE_DECREMENT(Final) \
BOOST_OPAQUE_USING_POST_DECREMENT(Final)
@@ -161,6 +181,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_LEFT_SHIFTABLE1(Final) \
BOOST_OPAQUE_USING_LEFT_SHIFT_ASSIGN(Final) \
BOOST_OPAQUE_USING_LEFT_SHIFT1(Final)
@@ -173,6 +195,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_RIGHT_SHIFTABLE1(Final) \
BOOST_OPAQUE_USING_RIGHT_SHIFT_ASSIGN(Final) \
BOOST_OPAQUE_USING_RIGHT_SHIFT1(Final)
@@ -185,6 +209,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_PARTIALLY_ORDERED1(Final,Bool) \
BOOST_OPAQUE_USING_LESS_THAN(Final,Bool) \
BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool) \
@@ -200,6 +226,8 @@
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool) \
BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool) \
BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool)
@@ -212,12 +240,16 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct additive2
//~ : opaque::addable2<T, U
//~ , opaque::subtractable2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_ADDITIVE1(Final) \
BOOST_OPAQUE_ADDABLE1(Final) \
BOOST_OPAQUE_SUBTRACTABLE1(Final)
@@ -229,17 +261,20 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct multiplicative2
//~ : opaque::multipliable2<T, U
//~ , opaque::dividable2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_MULTIPLICATIVE1(Final) \
BOOST_OPAQUE_MULTIPLIABLE1(Final) \
BOOST_OPAQUE_DIVIDABLE1(Final)
-
struct using_multiplicative1 {
template <typename Final, typename Base>
struct type : Base {
@@ -247,12 +282,16 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct integer_multiplicative2
//~ : opaque::multiplicative2<T, U
//~ , opaque::modable2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_INTEGER_MULTIPLICATIVE1(Final) \
BOOST_OPAQUE_MULTIPLICATIVE1(Final) \
BOOST_OPAQUE_MODABLE1(Final)
@@ -266,17 +305,20 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct arithmetic2
//~ : opaque::additive2<T, U
//~ , opaque::multiplicative2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_ARITHMETIC1(Final) \
BOOST_OPAQUE_ADDITIVE1(Final) \
BOOST_OPAQUE_MULTIPLICATIVE1(Final)
-
struct using_arithmetic1
{
template <typename Final, typename Base = base_new_type >
@@ -286,12 +328,16 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct integer_arithmetic2
//~ : additive2<T, U
//~ , integer_multiplicative2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_INTEGER_ARITHMETIC1(Final) \
BOOST_OPAQUE_ADDITIVE1(Final) \
BOOST_OPAQUE_INTEGER_MULTIPLICATIVE1(Final)
@@ -305,6 +351,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct bitwise2
//~ : opaque::xorable2<T, U
@@ -312,6 +360,8 @@
//~ , opaque::orable2<T, U, Base
//~ > > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_BITWISE1(Final) \
BOOST_OPAQUE_BITWISE_XORABLE1(Final) \
BOOST_OPAQUE_BITWISE_ANDABLE1(Final) \
@@ -326,6 +376,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_UNIT_STEPABLE(Final) \
BOOST_OPAQUE_INCREMENTABLE(Final) \
BOOST_OPAQUE_DECREMENTABLE(Final)
@@ -339,12 +391,16 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct shiftable2
//~ : opaque::left_shiftable2<T, U
//~ , opaque::right_shiftable2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_SHIFTABLE1(Final) \
BOOST_OPAQUE_LEFT_SHIFTABLE1(Final) \
BOOST_OPAQUE_RIGHT_SHIFTABLE1(Final)
@@ -358,6 +414,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct ring_operators2
//~ : opaque::additive2<T, U
@@ -365,6 +423,8 @@
//~ , opaque::multipliable2<T, U, Base
//~ > > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_RING1(Final) \
BOOST_OPAQUE_ADDITIVE1(Final) \
BOOST_OPAQUE_MULTIPLIABLE1(Final)
@@ -378,12 +438,16 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct ordered_ring_operators2
//~ : opaque::ring_operators2<T, U
//~ , opaque::totally_ordered2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_ORDERED_RING1(Final, Bool) \
BOOST_OPAQUE_RING1(Final) \
BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
@@ -398,6 +462,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct field_operators2
//~ : opaque::ring_operators2<T, U
@@ -405,6 +471,8 @@
//~ , opaque::dividable2_left<T, U, Base
//~ > > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_FIELD1(Final) \
BOOST_OPAQUE_RING1(Final) \
BOOST_OPAQUE_DIVIDABLE1(Final)
@@ -417,12 +485,17 @@
BOOST_OPAQUE_FIELD1(Final)
};
};
+
+//////////////////////////////////////////////////////////////////////////////
+
//~ template <class T, class U, typename Base = base_new_type >
//~ struct ordered_field_operators2
//~ : opaque::field_operators2<T, U
//~ , opaque::totally_ordered2<T, U, Base
//~ > > {};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_ORDERED_FIELD1(Final, Bool) \
BOOST_OPAQUE_FIELD1(Final) \
BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
Modified: sandbox/opaque/boost/opaque/meta_mixin/operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/meta_mixin/operators.hpp (original)
+++ sandbox/opaque/boost/opaque/meta_mixin/operators.hpp 2010-10-03 04:45:42 EDT (Sun, 03 Oct 2010)
@@ -18,6 +18,8 @@
namespace boost {
namespace opaque {
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_HIDING_COPY(T) \
private: \
T( const T& );
@@ -29,6 +31,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_HIDING_ASSIGN(T) \
private: \
T& operator=(T const&);
@@ -40,6 +44,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_CONVERSION(Final,UT) \
public: \
operator UT() const{ \
@@ -54,6 +60,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
template <typename T>
struct using_conversion_to {
template <typename Final, typename Base>
@@ -64,6 +72,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
struct using_safe_bool_conversion {
template <typename Final, typename Base>
struct type: Base {
@@ -76,6 +86,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_LESS_THAN(Final, Bool) \
public :\
Bool operator<(const Final& rhs) const { \
@@ -90,6 +102,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool) \
public :\
Bool operator<=(const Final& rhs) const { \
@@ -104,6 +118,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_GREATER_THAN(Final,Bool) \
public :\
Bool operator>(const Final& rhs) const { \
@@ -118,6 +134,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final,Bool) \
public :\
Bool operator>=(const Final& rhs) const { \
@@ -132,6 +150,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_EQUAL(Final,Bool) \
public :\
Bool operator==(const Final& rhs) const { \
@@ -146,6 +166,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool) \
public :\
Bool operator!=(const Final& rhs) const { \
@@ -160,6 +182,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_PLUS_ASSIGN(Final) \
public :\
Final& operator+=(const Final& rhs) { \
@@ -174,6 +198,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_MINUS_ASSIGN(Final) \
public :\
Final& operator-=(const Final& rhs) { \
@@ -188,6 +214,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_MULTIPLY_ASSIGN(Final) \
public :\
Final& operator*=(const Final& rhs) { \
@@ -202,6 +230,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_DIVIDE_ASSIGN(Final) \
public :\
Final& operator/=(const Final& rhs) { \
@@ -216,6 +246,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_MODULUS_ASSIGN(Final) \
public :\
Final& operator%=(const Final& rhs) { \
@@ -230,6 +262,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_XOR_ASSIGN(Final) \
public :\
Final& operator^=(const Final& rhs) { \
@@ -244,6 +278,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final) \
public :\
Final& operator&=(const Final& rhs) { \
@@ -258,6 +294,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
public :\
Final& operator|=(const Final& rhs) { \
@@ -272,6 +310,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_LEFT_SHIFT_ASSIGN(Final) \
public :\
Final& operator<<=(const Final& rhs) { \
@@ -286,6 +326,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_RIGHT_SHIFT_ASSIGN(Final) \
public :\
Final& operator>>=(const Final& rhs) { \
@@ -300,8 +342,10 @@
};
};
- // Unary operators
+// Unary operators
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_LOGICAL_NOT(Final) \
public :\
bool operator!() const { \
@@ -315,6 +359,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_UNARY_PLUS(Final) \
public :\
Final operator+() const { \
@@ -328,6 +374,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_UNARY_MINUS(Final) \
public :\
Final operator-() const { \
@@ -341,6 +389,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_NOT(Final) \
public :\
Final operator~() const { \
@@ -354,35 +404,45 @@
};
};
- //~ template <typename Final, typename Base>
- //~ struct address_of : Base {
- //~ Final* operator&() {
- //~ return this;
- //~ }
- //~ };
-
- //~ template <typename Final, typename Derreference=typename reference<Final::underlying_type>::type, typename Base>
- //~ struct derreference : Base {
- //~ Derreference operator*() {
- //~ return *(x.underlying());
- //~ }
- //~ };
-
- //~ template <typename Final, typename Pointer=typename pointer<Final::underlying_type>::type, typename Base>
- //~ struct member_access : Base {
- //~ Pointer operator->() {
- //~ return x.underlying().operator->();
- //~ }
- //~ };
-
- //~ template <typename Final, class I, class R, typename Base>
- //~ struct subscript : Base {
- //~ R operator[](I n) {
- //~ return x.underlying()[i];
- //~ }
- //~ };
-
- // Increment and decrement
+//////////////////////////////////////////////////////////////////////////////
+
+//~ template <typename Final, typename Base>
+//~ struct address_of : Base {
+//~ Final* operator&() {
+//~ return this;
+//~ }
+//~ };
+
+//////////////////////////////////////////////////////////////////////////////
+
+//~ template <typename Final, typename Derreference=typename reference<Final::underlying_type>::type, typename Base>
+//~ struct derreference : Base {
+//~ Derreference operator*() {
+//~ return *(x.underlying());
+//~ }
+//~ };
+
+//////////////////////////////////////////////////////////////////////////////
+
+//~ template <typename Final, typename Pointer=typename pointer<Final::underlying_type>::type, typename Base>
+//~ struct member_access : Base {
+//~ Pointer operator->() {
+//~ return x.underlying().operator->();
+//~ }
+//~ };
+
+//////////////////////////////////////////////////////////////////////////////
+
+//~ template <typename Final, class I, class R, typename Base>
+//~ struct subscript : Base {
+//~ R operator[](I n) {
+//~ return x.underlying()[i];
+//~ }
+//~ };
+
+// Increment and decrement
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_PRE_INCREMENT(Final) \
public :\
Final operator++() { \
@@ -397,6 +457,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_PRE_DECREMENT(Final) \
public :\
Final operator--() { \
@@ -411,6 +473,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_POST_INCREMENT(Final) \
public :\
Final operator++(int) { \
@@ -426,6 +490,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_POST_DECREMENT(Final) \
public :\
Final operator--(int) { \
@@ -444,6 +510,8 @@
#if 0
// I don't know why this doesn't works :(
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_PLUS(Final) \
public :\
Final operator+(const Final& rhs) const { \
@@ -468,6 +536,8 @@
}
#endif
+//////////////////////////////////////////////////////////////////////////////
+
struct using_plus {
template <typename Final, typename Base>
struct type: Base {
@@ -475,6 +545,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
struct using_minus {
template <typename Final, typename Base>
struct type: Base {
@@ -482,6 +554,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_MULTIPLY(Final) \
public :\
Final operator*(const Final& rhs) const { \
@@ -495,6 +569,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_DIVIDE(Final) \
public :\
Final operator/(const Final& rhs) const { \
@@ -509,6 +585,8 @@
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_MODULUS(Final) \
public :\
Final operator%(const Final& rhs) const { \
@@ -522,7 +600,8 @@
};
};
-
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_XOR(Final) \
public :\
Final operator^(const Final& rhs) const { \
@@ -537,6 +616,8 @@
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_OR(Final) \
public :\
Final operator|(const Final& rhs) const { \
@@ -550,6 +631,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_BITWISE_AND(Final) \
public :\
Final operator&(const Final& rhs) const { \
@@ -563,6 +646,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_LEFT_SHIFT1(Final) \
public :\
Final operator<<(const Final& rhs) const { \
@@ -576,6 +661,8 @@
};
};
+//////////////////////////////////////////////////////////////////////////////
+
#define BOOST_OPAQUE_USING_RIGHT_SHIFT1(Final) \
public :\
Final operator>>(const Final& rhs) const { \
@@ -592,5 +679,4 @@
}
}
-
#endif
Modified: sandbox/opaque/boost/opaque/new_class.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/new_class.hpp (original)
+++ sandbox/opaque/boost/opaque/new_class.hpp 2010-10-03 04:45:42 EDT (Sun, 03 Oct 2010)
@@ -19,7 +19,12 @@
class base_new_type {};
- template <typename Final, typename T, typename MetaMixinSeq=boost::mpl::vector0<>, typename Base=base_new_type >
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_new_type
+ >
class new_class : public linear_hierarchy<MetaMixinSeq, Final, Base>::type
{
public:
@@ -65,7 +70,13 @@
};
- template <typename T, typename Final, typename UT, typename MetaMixinSeq, typename Base >
+ template <
+ typename T,
+ typename Final,
+ typename UT,
+ typename MetaMixinSeq,
+ typename Base
+ >
T opaque_static_cast(new_class<Final, UT, MetaMixinSeq, Base> const& v)
{
return static_cast<T>(v.underlying());
Modified: sandbox/opaque/boost/opaque/new_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/new_type.hpp (original)
+++ sandbox/opaque/boost/opaque/new_type.hpp 2010-10-03 04:45:42 EDT (Sun, 03 Oct 2010)
@@ -19,11 +19,18 @@
namespace boost {
- template <typename T, typename Tag, typename Concepts=boost::mpl::vector0<>, typename Base=base_new_type>
+ template <
+ typename T,
+ typename Tag,
+ typename Concepts=boost::mpl::vector0<>,
+ typename Base=base_new_type
+ >
class new_type
- : public new_class<new_type<T, Tag, Concepts, Base>, T, Concepts, Base>
+ : public new_class<new_type<T, Tag, Concepts, Base>,
+ T, Concepts, Base>
{
- typedef new_class<new_type<T, Tag, Concepts, Base>, T, Concepts, Base> base_type;
+ typedef new_class<new_type<T, Tag, Concepts, Base>,
+ T, Concepts, Base> base_type;
public:
template <typename W>
explicit new_type(W v) : base_type(v) {}
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk