|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65747 - in sandbox/opaque/boost/opaque: . meta_mixin
From: vicente.botet_at_[hidden]
Date: 2010-10-04 07:29:09
Author: viboes
Date: 2010-10-04 07:29:06 EDT (Mon, 04 Oct 2010)
New Revision: 65747
URL: http://svn.boost.org/trac/boost/changeset/65747
Log:
Opaque:
* Cleanup
Text files modified:
sandbox/opaque/boost/opaque/meta_mixin/transitive_explicit_substituable.hpp | 30 +++++++-------
sandbox/opaque/boost/opaque/meta_mixin/transitive_substituable.hpp | 26 ++++++------
sandbox/opaque/boost/opaque/new_class.hpp | 18 ++++----
sandbox/opaque/boost/opaque/new_type.hpp | 12 +++---
sandbox/opaque/boost/opaque/private_opaque_class.hpp | 68 +++++++++++++++++-----------------
sandbox/opaque/boost/opaque/private_opaque_type.hpp | 20 +++++-----
sandbox/opaque/boost/opaque/public_opaque_class.hpp | 78 ++++++++++++++++++++--------------------
sandbox/opaque/boost/opaque/public_opaque_type.hpp | 22 +++++-----
8 files changed, 137 insertions(+), 137 deletions(-)
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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -27,27 +27,27 @@
namespace detail {
template <
- typename BaseClass,
- typename Final,
- typename UT,
- typename Base,
- bool B>
+ typename BaseClass,
+ typename Final,
+ typename UT,
+ typename Base,
+ bool B>
struct transitive_explicit_substituable_next_level;
template <
- typename BaseClass,
- typename Final,
- typename UT,
- typename Base>
+ 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 Base
+ typename BaseClass,
+ typename Final,
+ typename UT,
+ typename Base
>
struct transitive_explicit_substituable_next_level<BaseClass, Final, UT, Base, false>
: Base
@@ -68,7 +68,7 @@
{
#if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
friend UT convert_to(Final const& rhs,
- boost::dummy::type_tag<UT> const&)
+ boost::dummy::type_tag<UT> const&)
{
return Final::final(&rhs).underlying();
}
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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -25,28 +25,28 @@
namespace detail {
template <
- typename BaseClass,
- typename Final,
- typename UT,
- typename Base,
- bool IsConvertible
+ typename BaseClass,
+ typename Final,
+ typename UT,
+ typename Base,
+ bool IsConvertible
>
struct transitive_substituable_next_level;
template <
- typename BaseClass,
- typename Final,
- typename UT,
- typename Base
+ 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
+ : Base
{ };
}
@@ -56,9 +56,9 @@
template <typename Final, typename Base>
struct type
: detail::transitive_substituable_next_level<
- BaseClass, Final, UT, Base,
+ BaseClass, Final, UT, Base,
mpl::and_<is_class<UT>, is_base_of<BaseClass, UT>
- >::value>
+ >::value>
{
operator UT() const {
return Final::final(this).underlying();
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-04 07:29:06 EDT (Mon, 04 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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -20,17 +20,17 @@
template <
- typename T,
- typename Tag,
- typename Concepts=boost::mpl::vector0<>,
- typename Base=base_new_type
+ 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>
+ T, Concepts, Base>
{
typedef new_class<new_type<T, Tag, Concepts, Base>,
- T, Concepts, Base> base_type;
+ T, Concepts, Base> base_type;
public:
template <typename W>
explicit new_type(W v) : base_type(v) {}
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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -25,53 +25,53 @@
class base_private_opaque_type {};
template <
- typename Final,
- typename T,
- typename MetaMixinSeq=boost::mpl::vector0<>,
- typename Base=base_private_opaque_type
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_private_opaque_type
>
class private_opaque_class
- : public
+ : public
#if 0
- new_class< Final, T, MetaMixinSeq,
+ new_class< Final, T, MetaMixinSeq,
transitive_explicit_substituable<base_private_opaque_type,T>
- ::template type<Final,
+ ::template type<Final,
typename opaque::inherited_from_underlying<T>
- ::template type<Final, Base>
+ ::template type<Final, Base>
>
>
#else
- 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>
- >::type, Base
- >
+ 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>
+ >::type, Base
+ >
#endif
{
typedef
#if 0
- new_class< Final, T, MetaMixinSeq,
+ new_class< Final, T, MetaMixinSeq,
transitive_explicit_substituable<base_private_opaque_type,T>
- ::template type<Final,
+ ::template type<Final,
typename opaque::inherited_from_underlying<T>
- ::template type<Final, Base>
+ ::template type<Final, Base>
>
>
#else
- 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>
- >::type, Base
- >
+ 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>
+ >::type, Base
+ >
#endif
base_type;
@@ -79,17 +79,17 @@
//~ 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
- //~ conversion must be done through the underlying function
+ //~ 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)
- : base_type(rhs.val_) {}
+ : base_type(rhs.val_) {}
private_opaque_class(const Final & rhs)
- : base_type(rhs.val_) {}
+ : base_type(rhs.val_) {}
explicit private_opaque_class(T v)
- : base_type(v) {};
+ : base_type(v) {};
template <typename W>
explicit private_opaque_class(W v)
: base_type(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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -18,33 +18,33 @@
namespace boost {
template <
- typename T,
- typename Tag=void,
- typename MetaMixinSeq=boost::mpl::vector0<>,
- typename Base=base_private_opaque_type
+ 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>,
- T, MetaMixinSeq, Base>
+ T, MetaMixinSeq, Base>
{
typedef
private_opaque_class< private_opaque_type<T,Tag,MetaMixinSeq,Base>,
- T, 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
- //~ conversion must be done through the underlying function
+ //~ 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)
- : base_type(rhs.val_) {}
+ : base_type(rhs.val_) {}
explicit private_opaque_type(T v)
- : base_type(v) {};
+ : base_type(v) {};
template <typename W>
explicit private_opaque_type(W v)
: base_type(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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -33,7 +33,7 @@
template <typename T>
struct get_substituables<T,true> {
typedef typename mpl::push_front<typename T::substituables, T
- >::type type;
+ >::type type;
};
template <typename T>
@@ -45,9 +45,9 @@
struct transitive_substituable_help {
template <typename Final, typename Base>
struct type
- : transitive_substituable<BaseClass, UT>::template type<Final,
- typename opaque::inherited_from_underlying<UT>
- ::template type<Final, Base>
+ : transitive_substituable<BaseClass, UT>::template type<Final,
+ typename opaque::inherited_from_underlying<UT>
+ ::template type<Final, Base>
>
{
operator UT() const {
@@ -57,10 +57,10 @@
};
template <
- typename Final,
- typename T,
- typename MetaMixinSeq=boost::mpl::vector0<>,
- typename Base=base_public_opaque_type
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
>
class public_opaque_class
: public
@@ -69,25 +69,25 @@
#define COMPILER_WORKS
#if !defined(COMPILER_WORKS)
typename transitive_substituable_help<base_public_opaque_type,T>
- ::template type<Final, Base>
+ ::template type<Final, Base>
#else
typename transitive_substituable<base_public_opaque_type, T>
- ::template type<Final,
+ ::template type<Final,
typename opaque::inherited_from_underlying<T>
- ::template type<Final, Base>
+ ::template type<Final, Base>
>
#endif
>
#else
- 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>
- >::type, Base
- >
+ 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>
+ >::type, Base
+ >
#endif
{
@@ -96,33 +96,33 @@
new_class< Final, T, MetaMixinSeq,
#if !defined(COMPILER_WORKS)
typename transitive_substituable_help<base_public_opaque_type,T>
- ::template type<Final, Base>
+ ::template type<Final, Base>
#else
typename transitive_substituable<base_public_opaque_type, T>
- ::template type<Final,
+ ::template type<Final,
typename opaque::inherited_from_underlying<T>
- ::template type<Final, Base>
+ ::template type<Final, Base>
>
#endif
>
#else
- 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>
- >::type, Base
- >
+ 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>
+ >::type, Base
+ >
#endif
base_type;
public:
typedef typename get_substituables<T,
- mpl::and_< is_class<T>,
- is_base_of<base_public_opaque_type,T>
- >::value
+ mpl::and_< is_class<T>,
+ is_base_of<base_public_opaque_type,T>
+ >::value
>::type substituables;
//~ Can instances of UT be explicitly converted to instances of OT? Yes
@@ -132,14 +132,14 @@
public_opaque_class() {}
public_opaque_class(const public_opaque_class & rhs)
- : base_type(rhs.val_){}
+ : base_type(rhs.val_){}
public_opaque_class(const Final & rhs)
- : base_type(rhs.val_){}
+ : base_type(rhs.val_){}
explicit public_opaque_class(T v)
- : base_type(v) {}
+ : base_type(v) {}
template <typename W>
explicit public_opaque_class(W v)
- : base_type(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-04 07:29:06 EDT (Mon, 04 Oct 2010)
@@ -18,19 +18,19 @@
namespace boost {
template <
- typename T,
- typename Tag=void,
- typename MetaMixinSeq=boost::mpl::vector0<>,
- typename Base=base_public_opaque_type
+ 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>,
- T, MetaMixinSeq, Base>
+ public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
+ T, MetaMixinSeq, Base>
{
typedef
- public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
- T, MetaMixinSeq, Base> base_type;
+ public_opaque_class< public_opaque_type<T,Tag,MetaMixinSeq,Base>,
+ T, MetaMixinSeq, Base> base_type;
public:
//~ Can instances of UT be explicitly converted to instances of OT? Yes
@@ -40,12 +40,12 @@
public_opaque_type() {}
public_opaque_type(const public_opaque_type & rhs)
- : base_type(rhs.val_) {}
+ : base_type(rhs.val_) {}
explicit public_opaque_type(T v)
- : base_type(v) {}
+ : base_type(v) {}
template <typename W>
explicit public_opaque_type(W v)
- : base_type(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