|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65740 - in sandbox/opaque/boost/opaque: . meta_mixin
From: vicente.botet_at_[hidden]
Date: 2010-10-03 15:55:36
Author: viboes
Date: 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
New Revision: 65740
URL: http://svn.boost.org/trac/boost/changeset/65740
Log:
Opaque:
* Cleanup
Text files modified:
sandbox/opaque/boost/opaque/meta_mixin/operators.hpp | 125 ++++++++++++++++++++-------------------
sandbox/opaque/boost/opaque/meta_mixin/transitive_explicit_substituable.hpp | 34 +++++-----
sandbox/opaque/boost/opaque/meta_mixin/transitive_substituable.hpp | 22 +++---
sandbox/opaque/boost/opaque/new_class.hpp | 18 ++--
sandbox/opaque/boost/opaque/new_type.hpp | 12 +-
sandbox/opaque/boost/opaque/opaque.hpp | 1
sandbox/opaque/boost/opaque/private_opaque_class.hpp | 42 ++++++------
sandbox/opaque/boost/opaque/private_opaque_type.hpp | 18 ++--
sandbox/opaque/boost/opaque/public_opaque_class.hpp | 42 ++++++------
sandbox/opaque/boost/opaque/public_opaque_type.hpp | 22 +++---
10 files changed, 169 insertions(+), 167 deletions(-)
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 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -32,7 +32,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_HIDING_ASSIGN(T) \
private: \
T& operator=(T const&);
@@ -45,7 +45,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_CONVERSION(Final,UT) \
public: \
operator UT() const{ \
@@ -61,7 +61,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
template <typename T>
struct using_conversion_to {
template <typename Final, typename Base>
@@ -73,21 +73,21 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
struct using_safe_bool_conversion {
template <typename Final, typename Base>
struct type: Base {
typedef typename Final::underlying_type const& (Final::*unspecified_bool_type)() const;
operator unspecified_bool_type() const
- {
- return Final::underlying(this) ? &Final::underlying : 0;
+ {
+ return Final::underlying(this) ? &Final::underlying : 0;
}
};
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_LESS_THAN(Final, Bool) \
public :\
Bool operator<(const Final& rhs) const { \
@@ -103,7 +103,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool) \
public :\
Bool operator<=(const Final& rhs) const { \
@@ -119,7 +119,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_GREATER_THAN(Final,Bool) \
public :\
Bool operator>(const Final& rhs) const { \
@@ -135,7 +135,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final,Bool) \
public :\
Bool operator>=(const Final& rhs) const { \
@@ -151,7 +151,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_EQUAL(Final,Bool) \
public :\
Bool operator==(const Final& rhs) const { \
@@ -167,7 +167,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool) \
public :\
Bool operator!=(const Final& rhs) const { \
@@ -183,7 +183,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_PLUS_ASSIGN(Final) \
public :\
Final& operator+=(const Final& rhs) { \
@@ -199,7 +199,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_MINUS_ASSIGN(Final) \
public :\
Final& operator-=(const Final& rhs) { \
@@ -215,7 +215,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_MULTIPLY_ASSIGN(Final) \
public :\
Final& operator*=(const Final& rhs) { \
@@ -231,7 +231,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_DIVIDE_ASSIGN(Final) \
public :\
Final& operator/=(const Final& rhs) { \
@@ -247,7 +247,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_MODULUS_ASSIGN(Final) \
public :\
Final& operator%=(const Final& rhs) { \
@@ -263,7 +263,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_XOR_ASSIGN(Final) \
public :\
Final& operator^=(const Final& rhs) { \
@@ -279,7 +279,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final) \
public :\
Final& operator&=(const Final& rhs) { \
@@ -295,7 +295,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
public :\
Final& operator|=(const Final& rhs) { \
@@ -311,7 +311,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_LEFT_SHIFT_ASSIGN(Final) \
public :\
Final& operator<<=(const Final& rhs) { \
@@ -327,7 +327,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_RIGHT_SHIFT_ASSIGN(Final) \
public :\
Final& operator>>=(const Final& rhs) { \
@@ -335,7 +335,7 @@
return Final::final(this); \
}
- struct using_left_right_assign {
+ struct using_right_shift_assign {
template <typename Final, typename Base>
struct type: Base {
BOOST_OPAQUE_USING_RIGHT_SHIFT_ASSIGN(Final)
@@ -345,22 +345,23 @@
// Unary operators
//////////////////////////////////////////////////////////////////////////////
-
-#define BOOST_OPAQUE_USING_LOGICAL_NOT(Final) \
+
+#define BOOST_OPAQUE_USING_LOGICAL_NOT(Final,Bool) \
public :\
- bool operator!() const { \
- return !Final::underlying(this);\
+ Bool operator!() const { \
+ return Bool(!Final::underlying(this));\
}
+ template <typename Bool=bool>
struct using_logical_not {
template <typename Final, typename Base>
struct type: Base {
- BOOST_OPAQUE_USING_LOGICAL_NOT(Final)
+ BOOST_OPAQUE_USING_LOGICAL_NOT(Final,Bool)
};
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_UNARY_PLUS(Final) \
public :\
Final operator+() const { \
@@ -375,7 +376,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_UNARY_MINUS(Final) \
public :\
Final operator-() const { \
@@ -390,7 +391,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_NOT(Final) \
public :\
Final operator~() const { \
@@ -405,7 +406,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
//~ template <typename Final, typename Base>
//~ struct address_of : Base {
//~ Final* operator&() {
@@ -414,7 +415,7 @@
//~ };
//////////////////////////////////////////////////////////////////////////////
-
+
//~ template <typename Final, typename Derreference=typename reference<Final::underlying_type>::type, typename Base>
//~ struct derreference : Base {
//~ Derreference operator*() {
@@ -423,7 +424,7 @@
//~ };
//////////////////////////////////////////////////////////////////////////////
-
+
//~ template <typename Final, typename Pointer=typename pointer<Final::underlying_type>::type, typename Base>
//~ struct member_access : Base {
//~ Pointer operator->() {
@@ -432,7 +433,7 @@
//~ };
//////////////////////////////////////////////////////////////////////////////
-
+
//~ template <typename Final, class I, class R, typename Base>
//~ struct subscript : Base {
//~ R operator[](I n) {
@@ -442,10 +443,10 @@
// Increment and decrement
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_PRE_INCREMENT(Final) \
public :\
- Final operator++() { \
+ Final& operator++() { \
++Final::underlying(this); \
return Final::final(this); \
}
@@ -458,10 +459,10 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_PRE_DECREMENT(Final) \
public :\
- Final operator--() { \
+ Final& operator--() { \
--Final::underlying(this); \
return Final::final(this); \
}
@@ -474,7 +475,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_POST_INCREMENT(Final) \
public :\
Final operator++(int) { \
@@ -491,7 +492,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_POST_DECREMENT(Final) \
public :\
Final operator--(int) { \
@@ -511,7 +512,7 @@
// I don't know why this doesn't works :(
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_PLUS(Final) \
public :\
Final operator+(const Final& rhs) const { \
@@ -537,7 +538,7 @@
#endif
//////////////////////////////////////////////////////////////////////////////
-
+
struct using_plus {
template <typename Final, typename Base>
struct type: Base {
@@ -546,7 +547,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
struct using_minus {
template <typename Final, typename Base>
struct type: Base {
@@ -555,7 +556,7 @@
};
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_MULTIPLY(Final) \
public :\
Final operator*(const Final& rhs) const { \
@@ -568,9 +569,9 @@
BOOST_OPAQUE_USING_MULTIPLY(Final)
};
};
-
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_DIVIDE(Final) \
public :\
Final operator/(const Final& rhs) const { \
@@ -583,10 +584,10 @@
BOOST_OPAQUE_USING_DIVIDE(Final)
};
};
-
-
+
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_MODULUS(Final) \
public :\
Final operator%(const Final& rhs) const { \
@@ -599,9 +600,9 @@
BOOST_OPAQUE_USING_MODULUS(Final)
};
};
-
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_XOR(Final) \
public :\
Final operator^(const Final& rhs) const { \
@@ -614,10 +615,10 @@
BOOST_OPAQUE_USING_BITWISE_XOR(Final)
};
};
-
-
+
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_OR(Final) \
public :\
Final operator|(const Final& rhs) const { \
@@ -630,9 +631,9 @@
BOOST_OPAQUE_USING_BITWISE_OR(Final)
};
};
-
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_BITWISE_AND(Final) \
public :\
Final operator&(const Final& rhs) const { \
@@ -645,9 +646,9 @@
BOOST_OPAQUE_USING_BITWISE_AND(Final)
};
};
-
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_LEFT_SHIFT1(Final) \
public :\
Final operator<<(const Final& rhs) const { \
@@ -660,9 +661,9 @@
BOOST_OPAQUE_USING_LEFT_SHIFT1(Final)
};
};
-
+
//////////////////////////////////////////////////////////////////////////////
-
+
#define BOOST_OPAQUE_USING_RIGHT_SHIFT1(Final) \
public :\
Final operator>>(const Final& rhs) const { \
@@ -675,7 +676,7 @@
BOOST_OPAQUE_USING_RIGHT_SHIFT1(Final)
};
};
-
+
}
}
Modified: sandbox/opaque/boost/opaque/meta_mixin/transitive_explicit_substituable.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/meta_mixin/transitive_explicit_substituable.hpp (original)
+++ sandbox/opaque/boost/opaque/meta_mixin/transitive_explicit_substituable.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -23,34 +23,34 @@
template <typename BaseClass, typename UT>
struct transitive_explicit_substituable;
-
+
namespace detail {
template <
- typename BaseClass,
- typename Final,
- typename UT,
- typename Base,
+ typename BaseClass,
+ typename Final,
+ typename UT,
+ typename Base,
bool B>
struct transitive_explicit_substituable_next_level;
template <
- typename BaseClass,
- typename Final,
- typename UT,
+ typename BaseClass,
+ typename Final,
+ typename UT,
typename Base>
struct transitive_explicit_substituable_next_level<BaseClass, Final, UT, Base, true>
: transitive_explicit_substituable<BaseClass, typename UT::underlying_type>
- ::template type<Final, Base>
+ ::template type<Final, Base>
{};
template <
- typename BaseClass,
- typename Final,
- typename UT,
+ typename BaseClass,
+ typename Final,
+ typename UT,
typename Base
>
- struct transitive_explicit_substituable_next_level<BaseClass, Final, UT, Base, false>
- : Base
+ struct transitive_explicit_substituable_next_level<BaseClass, Final, UT, Base, false>
+ : Base
{};
}
@@ -67,20 +67,20 @@
mpl::and_<is_class<UT>, is_base_of<BaseClass, UT> >::value>
{
#if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
- friend UT convert_to(Final const& rhs,
+ friend UT convert_to(Final const& rhs,
boost::dummy::type_tag<UT> const&)
{
return Final::final(&rhs).underlying();
}
#else
- explicit operator UT() const
+ explicit operator UT() const
{
return Final::final(this).underlying();
}
#endif
};
};
-
+
}
Modified: sandbox/opaque/boost/opaque/meta_mixin/transitive_substituable.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/meta_mixin/transitive_substituable.hpp (original)
+++ sandbox/opaque/boost/opaque/meta_mixin/transitive_substituable.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -25,28 +25,28 @@
namespace detail {
template <
- typename BaseClass,
- typename Final,
- typename UT,
- typename Base,
+ typename BaseClass,
+ typename Final,
+ typename UT,
+ typename Base,
bool IsConvertible
>
struct transitive_substituable_next_level;
template <
- typename BaseClass,
- typename Final,
- typename UT,
+ typename BaseClass,
+ typename Final,
+ typename UT,
typename Base
>
struct transitive_substituable_next_level<BaseClass, Final, UT, Base, true>
: transitive_substituable<BaseClass, typename UT::underlying_type>
- ::template type<Final, Base>
+ ::template type<Final, Base>
{ };
template <typename BaseClass, typename Final, typename UT, typename Base>
- struct transitive_substituable_next_level<BaseClass, Final, UT, Base, false>
- : Base
+ struct transitive_substituable_next_level<BaseClass, Final, UT, Base, false>
+ : Base
{ };
}
@@ -57,7 +57,7 @@
struct type
: detail::transitive_substituable_next_level<
BaseClass, Final, UT, Base,
- mpl::and_<is_class<UT>, is_base_of<BaseClass, UT>
+ mpl::and_<is_class<UT>, is_base_of<BaseClass, UT>
>::value>
{
operator UT() const {
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 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -20,10 +20,10 @@
class base_new_type {};
template <
- typename Final,
- typename T,
- typename MetaMixinSeq=boost::mpl::vector0<>,
- typename Base=base_new_type
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_new_type
>
class new_class : public linear_hierarchy<MetaMixinSeq, Final, Base>::type
{
@@ -71,11 +71,11 @@
};
template <
- typename T,
- typename Final,
- typename UT,
- typename MetaMixinSeq,
- typename Base
+ typename T,
+ typename Final,
+ typename UT,
+ typename MetaMixinSeq,
+ typename Base
>
T opaque_static_cast(new_class<Final, UT, MetaMixinSeq, Base> const& v)
{
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 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -20,16 +20,16 @@
template <
- typename T,
- typename Tag,
- typename Concepts=boost::mpl::vector0<>,
+ 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>,
+ class new_type
+ : public new_class<new_type<T, Tag, Concepts, Base>,
T, Concepts, Base>
{
- typedef new_class<new_type<T, Tag, Concepts, Base>,
+ typedef new_class<new_type<T, Tag, Concepts, Base>,
T, Concepts, Base> base_type;
public:
template <typename W>
Modified: sandbox/opaque/boost/opaque/opaque.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/opaque.hpp (original)
+++ sandbox/opaque/boost/opaque/opaque.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -69,4 +69,5 @@
#endif
}
+
#endif
Modified: sandbox/opaque/boost/opaque/private_opaque_class.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/private_opaque_class.hpp (original)
+++ sandbox/opaque/boost/opaque/private_opaque_class.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -25,14 +25,14 @@
class base_private_opaque_type {};
template <
- typename Final,
- typename T,
- typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
typename Base=base_private_opaque_type
>
- class private_opaque_class
+ class private_opaque_class
: public
-#if 0
+#if 0
new_class< Final, T, MetaMixinSeq,
transitive_explicit_substituable<base_private_opaque_type,T>
::template type<Final,
@@ -41,20 +41,20 @@
>
>
#else
- new_class< Final, T,
+ new_class< Final, T,
typename mpl::push_back<
typename mpl::push_back<
MetaMixinSeq,
- transitive_explicit_substituable<base_private_opaque_type, T>
- >::type,
- opaque::inherited_from_underlying<T>
+ transitive_explicit_substituable<base_private_opaque_type, T>
+ >::type,
+ opaque::inherited_from_underlying<T>
>::type, Base
- >
+ >
#endif
{
typedef
-#if 0
+#if 0
new_class< Final, T, MetaMixinSeq,
transitive_explicit_substituable<base_private_opaque_type,T>
::template type<Final,
@@ -63,32 +63,32 @@
>
>
#else
- new_class< Final, T,
+ new_class< Final, T,
typename mpl::push_back<
typename mpl::push_back<
MetaMixinSeq,
- transitive_explicit_substituable<base_private_opaque_type, T>
- >::type,
- opaque::inherited_from_underlying<T>
+ transitive_explicit_substituable<base_private_opaque_type, T>
+ >::type,
+ opaque::inherited_from_underlying<T>
>::type, Base
- >
+ >
#endif
base_type;
-
+
public:
//~ Can instances of UT be explicitly converted to instances of OT? Yes
//~ Can instances of UT be implicitly converted to instances of OT? No
//~ Can instances of OT be explicitly converted to instances of UT? Yes.
- //~ Waiting for explicit conversion operators,, the explicit
+ //~ Waiting for explicit conversion operators,, the explicit
//~ conversion must be done through the underlying function
//~ Can instances of OT be implicitly converted to instances of UT? No
private_opaque_class() {};
- private_opaque_class(const private_opaque_class & rhs)
+ private_opaque_class(const private_opaque_class & rhs)
: base_type(rhs.val_) {}
- private_opaque_class(const Final & rhs)
+ private_opaque_class(const Final & rhs)
: base_type(rhs.val_) {}
- explicit private_opaque_class(T v)
+ explicit private_opaque_class(T v)
: base_type(v) {};
template <typename W>
explicit private_opaque_class(W v)
Modified: sandbox/opaque/boost/opaque/private_opaque_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/private_opaque_type.hpp (original)
+++ sandbox/opaque/boost/opaque/private_opaque_type.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -18,32 +18,32 @@
namespace boost {
template <
- typename T,
- typename Tag=void,
- typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename T,
+ typename Tag=void,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
typename Base=base_private_opaque_type
>
class private_opaque_type : public
- private_opaque_class< private_opaque_type<T,Tag,MetaMixinSeq,Base>,
+ private_opaque_class< private_opaque_type<T,Tag,MetaMixinSeq,Base>,
T, MetaMixinSeq, Base>
{
typedef
- private_opaque_class< private_opaque_type<T,Tag,MetaMixinSeq,Base>,
+ private_opaque_class< private_opaque_type<T,Tag,MetaMixinSeq,Base>,
T, MetaMixinSeq, Base>
base_type;
-
+
public:
//~ Can instances of UT be explicitly converted to instances of OT? Yes
//~ Can instances of UT be implicitly converted to instances of OT? No
//~ Can instances of OT be explicitly converted to instances of UT? Yes.
- //~ Waiting for explicit conversion operators,, the explicit
+ //~ Waiting for explicit conversion operators,, the explicit
//~ conversion must be done through the underlying function
//~ Can instances of OT be implicitly converted to instances of UT? No
private_opaque_type() {};
- private_opaque_type(const private_opaque_type & rhs)
+ private_opaque_type(const private_opaque_type & rhs)
: base_type(rhs.val_) {}
- explicit private_opaque_type(T v)
+ explicit private_opaque_type(T v)
: base_type(v) {};
template <typename W>
explicit private_opaque_type(W v)
Modified: sandbox/opaque/boost/opaque/public_opaque_class.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/public_opaque_class.hpp (original)
+++ sandbox/opaque/boost/opaque/public_opaque_class.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -44,7 +44,7 @@
template <typename BaseClass, typename UT>
struct transitive_substituable_help {
template <typename Final, typename Base>
- struct type
+ struct type
: transitive_substituable<BaseClass, UT>::template type<Final,
typename opaque::inherited_from_underlying<UT>
::template type<Final, Base>
@@ -57,14 +57,14 @@
};
template <
- typename Final,
- typename T,
- typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
typename Base=base_public_opaque_type
>
class public_opaque_class
: public
-#if 0
+#if 0
new_class< Final, T, MetaMixinSeq,
#define COMPILER_WORKS
#if !defined(COMPILER_WORKS)
@@ -79,20 +79,20 @@
#endif
>
#else
- new_class< Final, T,
+ new_class< Final, T,
typename mpl::push_back<
typename mpl::push_back<
MetaMixinSeq,
- transitive_substituable<base_public_opaque_type, T>
- >::type,
- opaque::inherited_from_underlying<T>
+ transitive_substituable<base_public_opaque_type, T>
+ >::type,
+ opaque::inherited_from_underlying<T>
>::type, Base
- >
+ >
#endif
{
typedef
-#if 0
+#if 0
new_class< Final, T, MetaMixinSeq,
#if !defined(COMPILER_WORKS)
typename transitive_substituable_help<base_public_opaque_type,T>
@@ -106,13 +106,13 @@
#endif
>
#else
- new_class< Final, T,
+ new_class< Final, T,
typename mpl::push_back<
typename mpl::push_back<
MetaMixinSeq,
- transitive_substituable<base_public_opaque_type, T>
- >::type,
- opaque::inherited_from_underlying<T>
+ transitive_substituable<base_public_opaque_type, T>
+ >::type,
+ opaque::inherited_from_underlying<T>
>::type, Base
>
#endif
@@ -120,8 +120,8 @@
public:
typedef typename get_substituables<T,
- mpl::and_< is_class<T>,
- is_base_of<base_public_opaque_type,T>
+ mpl::and_< is_class<T>,
+ is_base_of<base_public_opaque_type,T>
>::value
>::type substituables;
@@ -131,14 +131,14 @@
//~ Can instances of OT be implicitly converted to instances of UT? Yes
public_opaque_class() {}
- public_opaque_class(const public_opaque_class & rhs)
+ public_opaque_class(const public_opaque_class & rhs)
: base_type(rhs.val_){}
- public_opaque_class(const Final & rhs)
+ public_opaque_class(const Final & rhs)
: base_type(rhs.val_){}
- explicit public_opaque_class(T v)
+ explicit public_opaque_class(T v)
: base_type(v) {}
template <typename W>
- explicit public_opaque_class(W v)
+ explicit public_opaque_class(W v)
: base_type(v) {}
};
Modified: sandbox/opaque/boost/opaque/public_opaque_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/public_opaque_type.hpp (original)
+++ sandbox/opaque/boost/opaque/public_opaque_type.hpp 2010-10-03 15:55:33 EDT (Sun, 03 Oct 2010)
@@ -18,18 +18,18 @@
namespace boost {
template <
- typename T,
- typename Tag=void,
- typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename T,
+ typename Tag=void,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
typename Base=base_public_opaque_type
>
class public_opaque_type
- : public
- public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
+ : public
+ public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
T, MetaMixinSeq, Base>
{
- typedef
- public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
+ typedef
+ public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
T, MetaMixinSeq, Base> base_type;
public:
@@ -39,16 +39,16 @@
//~ Can instances of OT be implicitly converted to instances of UT? Yes
public_opaque_type() {}
- public_opaque_type(const public_opaque_type & rhs)
+ public_opaque_type(const public_opaque_type & rhs)
: base_type(rhs.val_) {}
- explicit public_opaque_type(T v)
+ explicit public_opaque_type(T v)
: base_type(v) {}
template <typename W>
- explicit public_opaque_type(W v)
+ explicit public_opaque_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