|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r56070 - in sandbox/itl/boost/itl: . type_traits
From: afojgo_at_[hidden]
Date: 2009-09-06 12:16:27
Author: jofaber
Date: 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
New Revision: 56070
URL: http://svn.boost.org/trac/boost/changeset/56070
Log:
Refactoring, portability: BOOST_STATIC_CONSTANT introduced.
Text files modified:
sandbox/itl/boost/itl/interval_base_map.hpp | 8
sandbox/itl/boost/itl/interval_base_set.hpp | 4
sandbox/itl/boost/itl/interval_map.hpp | 12 +-
sandbox/itl/boost/itl/interval_set.hpp | 4
sandbox/itl/boost/itl/map.hpp | 10
sandbox/itl/boost/itl/separate_interval_set.hpp | 6
sandbox/itl/boost/itl/set.hpp | 10
sandbox/itl/boost/itl/split_interval_map.hpp | 14 +-
sandbox/itl/boost/itl/split_interval_set.hpp | 6
sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp | 2
sandbox/itl/boost/itl/type_traits/has_inverse.hpp | 2
sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 205 ++++++++++++++++++++++-----------------
sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp | 5
sandbox/itl/boost/itl/type_traits/is_continuous.hpp | 10
sandbox/itl/boost/itl/type_traits/is_element_container.hpp | 10 +
sandbox/itl/boost/itl/type_traits/is_interval_container.hpp | 14 +
sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp | 2
sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp | 2
sandbox/itl/boost/itl/type_traits/is_map.hpp | 2
sandbox/itl/boost/itl/type_traits/is_set.hpp | 2
sandbox/itl/boost/itl/type_traits/is_total.hpp | 2
21 files changed, 183 insertions(+), 149 deletions(-)
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -1490,7 +1490,7 @@
struct is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template
@@ -1501,7 +1501,7 @@
struct is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template
@@ -1512,7 +1512,7 @@
struct has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
template
@@ -1523,7 +1523,7 @@
struct is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -745,7 +745,7 @@
struct is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template<class SubType,
@@ -753,7 +753,7 @@
struct is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -750,21 +750,21 @@
struct is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
@@ -772,21 +772,21 @@
struct is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::absorbs_neutrons;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::is_total;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total));
};
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -327,14 +327,14 @@
struct is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -1064,33 +1064,33 @@
struct is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct is_map<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef is_map<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct has_inverse<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef has_inverse<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
-{ static const bool value = false; };
+{ BOOST_STATIC_CONSTANT(bool, value = false); };
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -239,21 +239,21 @@
struct is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -658,27 +658,27 @@
struct is_set<itl::set<Type> >
{
typedef is_set<itl::set<Type> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class Type>
struct is_interval_container<itl::set<Type> >
{
typedef is_interval_container<itl::set<Type> > type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
template <class Type>
struct is_interval_splitter<itl::set<Type> >
-{ static const bool value = false; };
+{ BOOST_STATIC_CONSTANT(bool, value = false); };
template <class Type>
struct absorbs_neutrons<itl::set<Type> >
-{ static const bool value = false; };
+{ BOOST_STATIC_CONSTANT(bool, value = false); };
template <class Type>
struct is_total<itl::set<Type> >
-{ static const bool value = false; };
+{ BOOST_STATIC_CONSTANT(bool, value = false); };
template <class Type>
struct type_to_string<itl::set<Type> >
Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -609,49 +609,49 @@
struct is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- enum{value = true};
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::absorbs_neutrons;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::is_total;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total));
};
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -340,21 +340,21 @@
struct is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -13,7 +13,7 @@
template <class Type> struct absorbs_neutrons
{
typedef absorbs_neutrons<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/has_inverse.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/has_inverse.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/has_inverse.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -16,7 +16,7 @@
template <class Type> struct has_inverse
{
typedef has_inverse<Type> type;
- static const bool value = is_signed<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (is_signed<Type>::value));
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -23,8 +23,9 @@
struct is_overloadable
{
typedef is_overloadable<Type> type;
- static const bool value =
- is_same<Type, typename Type::overloadable_type>::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (is_same<Type, typename Type::overloadable_type>::value)
+ );
};
@@ -33,9 +34,10 @@
struct is_codomain_equal
{
typedef is_codomain_equal<LeftT, RightT> type;
- static const bool value =
- is_same<typename LeftT::codomain_type,
- typename RightT::codomain_type>::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (is_same<typename LeftT::codomain_type,
+ typename RightT::codomain_type>::value)
+ );
};
//NOTE: Equality of compare order implies the equality of the domain_types
@@ -43,18 +45,20 @@
struct is_domain_compare_equal
{
typedef is_domain_compare_equal<LeftT, RightT> type;
- static const bool value =
- is_same<typename LeftT::domain_compare,
- typename RightT::domain_compare>::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (is_same<typename LeftT::domain_compare,
+ typename RightT::domain_compare>::value)
+ );
};
template<class LeftT, class RightT>
struct is_codomain_type_equal
{
typedef is_codomain_type_equal<LeftT, RightT> type;
- static const bool value =
- mpl::and_<is_domain_compare_equal<LeftT, RightT>,
- is_codomain_equal<LeftT, RightT> >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_<is_domain_compare_equal<LeftT, RightT>,
+ is_codomain_equal<LeftT, RightT> >::value)
+ );
};
@@ -63,12 +67,13 @@
struct is_concept_compatible
{
typedef is_concept_compatible<IsConcept, LeftT, RightT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >
, is_codomain_type_equal<LeftT, RightT>
- >::value;
+ >::value)
+ );
};
template<template<class>class LeftConcept,
@@ -77,24 +82,26 @@
struct is_concept_combinable
{
typedef is_concept_combinable<LeftConcept, RightConcept, LeftT, RightT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
mpl::and_<LeftConcept<LeftT>, RightConcept<RightT> >
, is_domain_compare_equal<LeftT, RightT>
- >::value;
+ >::value)
+ );
};
template<class LeftT, class RightT>
struct is_intra_combinable
{
typedef is_intra_combinable<LeftT, RightT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
is_concept_compatible<is_interval_set, LeftT, RightT>
, is_concept_compatible<is_interval_map, LeftT, RightT>
- >::value;
+ >::value)
+ );
};
//------------------------------------------------------------------------------
@@ -105,21 +112,23 @@
struct is_cross_combinable
{
typedef is_cross_combinable<LeftT, RightT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
is_concept_combinable<is_interval_set, is_interval_map, LeftT, RightT>
, is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>
- >::value;
+ >::value)
+ );
};
template<class LeftT, class RightT>
struct is_inter_combinable
{
typedef is_inter_combinable<LeftT, RightT> type;
- static const bool value =
- mpl::or_<is_intra_combinable<LeftT,RightT>,
- is_cross_combinable<LeftT,RightT> >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_<is_intra_combinable<LeftT,RightT>,
+ is_cross_combinable<LeftT,RightT> >::value)
+ );
};
//------------------------------------------------------------------------------
@@ -132,21 +141,21 @@
struct is_interval_set_derivative<Type, typename Type::domain_type>
{
typedef is_interval_set_derivative<Type, typename Type::domain_type> type;
- static const bool value = is_interval_container<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (is_interval_container<Type>::value));
};
template<class Type>
struct is_interval_set_derivative<Type, typename Type::interval_type>
{
typedef is_interval_set_derivative<Type, typename Type::interval_type> type;
- static const bool value = is_interval_container<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (is_interval_container<Type>::value));
};
template<class Type, class AssociateT>
struct is_interval_set_derivative
{
typedef is_interval_set_derivative<Type, AssociateT> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
//------------------------------------------------------------------------------
@@ -159,28 +168,28 @@
struct is_interval_map_derivative<Type, typename Type::domain_mapping_type>
{
typedef is_interval_map_derivative<Type, typename Type::domain_mapping_type> type;
- static const bool value = is_interval_container<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (is_interval_container<Type>::value));
};
template<class Type>
struct is_interval_map_derivative<Type, typename Type::interval_mapping_type>
{
typedef is_interval_map_derivative<Type, typename Type::interval_mapping_type> type;
- static const bool value = is_interval_container<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (is_interval_container<Type>::value));
};
template<class Type>
struct is_interval_map_derivative<Type, typename Type::value_type>
{
typedef is_interval_map_derivative<Type, typename Type::value_type> type;
- static const bool value = is_interval_container<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value = (is_interval_container<Type>::value));
};
template<class Type, class AssociateT>
struct is_interval_map_derivative
{
typedef is_interval_map_derivative<Type, AssociateT> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
//------------------------------------------------------------------------------
@@ -190,38 +199,41 @@
struct is_intra_derivative
{
typedef is_intra_derivative<Type, AssociateT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
mpl::and_<is_interval_set<Type>,
is_interval_set_derivative<Type, AssociateT> >
, mpl::and_<is_interval_map<Type>,
is_interval_map_derivative<Type, AssociateT> >
- >::value;
+ >::value)
+ );
};
template<class Type, class AssociateT>
struct is_cross_derivative
{
typedef is_cross_derivative<Type, AssociateT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
is_interval_map<Type>
, is_interval_set_derivative<Type, AssociateT>
- >::value;
+ >::value)
+ );
};
template<class Type, class AssociateT>
struct is_inter_derivative
{
typedef is_inter_derivative<Type, AssociateT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
is_intra_derivative<Type, AssociateT>
, is_cross_derivative<Type, AssociateT>
- >::value;
+ >::value)
+ );
};
//------------------------------------------------------------------------------
@@ -232,8 +244,8 @@
struct is_interval_set_right_combinable
{
typedef is_interval_set_right_combinable<GuideT, CompanionT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
is_interval_set<GuideT>
, mpl::or_
@@ -241,15 +253,16 @@
is_interval_set_derivative<GuideT, CompanionT>
, is_concept_compatible<is_interval_set, GuideT, CompanionT>
>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_interval_map_right_intra_combinable
{
typedef is_interval_map_right_intra_combinable<GuideT, CompanionT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
is_interval_map<GuideT>
, mpl::or_
@@ -257,15 +270,16 @@
is_interval_map_derivative<GuideT, CompanionT>
, is_concept_compatible<is_interval_map, GuideT, CompanionT>
>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_interval_map_right_cross_combinable
{
typedef is_interval_map_right_cross_combinable<GuideT, CompanionT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
is_interval_map<GuideT>
, mpl::or_
@@ -273,19 +287,21 @@
is_cross_derivative<GuideT, CompanionT>
, is_concept_combinable<is_interval_map, is_interval_set, GuideT, CompanionT>
>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_interval_map_right_inter_combinable
{
typedef is_interval_map_right_inter_combinable<GuideT, CompanionT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
is_interval_map_right_intra_combinable<GuideT, CompanionT>
, is_interval_map_right_cross_combinable<GuideT, CompanionT>
- >::value;
+ >::value)
+ );
};
@@ -293,50 +309,54 @@
struct is_right_intra_combinable
{
typedef is_right_intra_combinable<GuideT, CompanionT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
is_interval_set_right_combinable<GuideT, CompanionT>
, is_interval_map_right_intra_combinable<GuideT, CompanionT>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_right_inter_combinable
{
typedef is_right_inter_combinable<GuideT, CompanionT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
is_interval_set_right_combinable<GuideT, CompanionT>
, is_interval_map_right_inter_combinable<GuideT, CompanionT>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class IntervalSetT>
struct combines_right_to_interval_set
{
typedef combines_right_to_interval_set<GuideT, IntervalSetT> type;
- static const bool value =
- is_concept_combinable<is_interval_container, is_interval_set,
- GuideT, IntervalSetT>::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (is_concept_combinable<is_interval_container, is_interval_set,
+ GuideT, IntervalSetT>::value)
+ );
};
template<class GuideT, class IntervalMapT>
struct combines_right_to_interval_map
{
typedef combines_right_to_interval_map<GuideT, IntervalMapT> type;
- static const bool value =
- is_concept_compatible<is_interval_map, GuideT, IntervalMapT>::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (is_concept_compatible<is_interval_map, GuideT, IntervalMapT>::value) );
};
template<class GuideT, class IntervalContainerT>
struct combines_right_to_interval_container
{
typedef combines_right_to_interval_container<GuideT, IntervalContainerT> type;
- static const bool value =
- mpl::or_<combines_right_to_interval_set<GuideT, IntervalContainerT>,
- combines_right_to_interval_map<GuideT, IntervalContainerT> >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_<combines_right_to_interval_set<GuideT, IntervalContainerT>,
+ combines_right_to_interval_map<GuideT, IntervalContainerT> >::value)
+ );
};
@@ -376,12 +396,13 @@
template<class GuideT, class CompanionT> struct is_interval_set_companion
{
typedef is_interval_set_companion<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
combines_right_to_interval_set<GuideT,CompanionT>
, is_interval_set_derivative<GuideT,CompanionT>
- >::value;
+ >::value)
+ );
};
@@ -392,12 +413,13 @@
template<class GuideT, class CompanionT> struct is_interval_map_companion
{
typedef is_interval_map_companion<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
combines_right_to_interval_map<GuideT,CompanionT>
, is_interval_map_derivative<GuideT,CompanionT>
- >::value;
+ >::value)
+ );
};
@@ -408,26 +430,28 @@
struct is_coarser_interval_set_companion
{
typedef is_coarser_interval_set_companion<GuideT, CompanionT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
is_interval_set_companion<GuideT, CompanionT>
, mpl::bool_<( segmentational_fineness<GuideT>::value
> segmentational_fineness<CompanionT>::value)>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_coarser_interval_map_companion
{
typedef is_coarser_interval_map_companion<GuideT, CompanionT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
<
is_interval_map_companion<GuideT, CompanionT>
, mpl::bool_<( segmentational_fineness<GuideT>::value
> segmentational_fineness<CompanionT>::value)>
- >::value;
+ >::value)
+ );
};
//------------------------------------------------------------------------------
@@ -457,36 +481,39 @@
struct is_binary_intra_combinable
{
typedef is_binary_intra_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_<is_binary_interval_set_combinable<GuideT, CompanionT>,
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_<is_binary_interval_set_combinable<GuideT, CompanionT>,
is_binary_interval_map_combinable<GuideT, CompanionT>
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_binary_cross_combinable
{
typedef is_binary_cross_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::and_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_
< is_interval_map<GuideT>
, mpl::or_< is_coarser_interval_map_companion<GuideT, CompanionT>
, is_interval_set_companion<GuideT, CompanionT> >
- >::value;
+ >::value)
+ );
};
template<class GuideT, class CompanionT>
struct is_binary_inter_combinable
{
typedef is_binary_inter_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::or_
<
mpl::and_<is_interval_map<GuideT>,
is_binary_cross_combinable<GuideT, CompanionT> >
, mpl::and_<is_interval_set<GuideT>,
is_binary_intra_combinable<GuideT, CompanionT> >
- >::value;
+ >::value)
+ );
};
Modified: sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -17,8 +17,9 @@
struct is_concept_equivalent
{
typedef is_concept_equivalent<IsConcept, LeftT, RightT> type;
- static const bool value =
- mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >::value)
+ );
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_continuous.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_continuous.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_continuous.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -17,17 +17,17 @@
template<> struct is_continuous<float>
{
typedef is_continuous<float> type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template<> struct is_continuous<double>
{
typedef is_continuous<double> type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template<> struct is_continuous<std::string>
{
typedef is_continuous<std::string> type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
#ifdef ITL_NEEDS_RATIONAL_IS_CONTINUOUS
@@ -36,14 +36,14 @@
struct is_continuous<boost::rational<Integral> >
{
typedef is_continuous<boost::rational<Integral> > type;
- static const bool value = true;
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
#endif
template <class Type> struct is_continuous
{
typedef is_continuous<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
Modified: sandbox/itl/boost/itl/type_traits/is_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_element_container.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -20,16 +20,18 @@
struct is_element_container
{
typedef is_element_container<Type> type;
- static const bool value =
- mpl::and_<is_set<Type>, mpl::not_<is_interval_container<Type> > >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_<is_set<Type>, mpl::not_<is_interval_container<Type> > >::value)
+ );
};
template<class Type>
struct is_element_map
{
typedef is_element_map<Type> type;
- static const bool value =
- mpl::and_<is_map<Type>, mpl::not_<is_interval_container<Type> > >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_<is_map<Type>, mpl::not_<is_interval_container<Type> > >::value)
+ );
};
Modified: sandbox/itl/boost/itl/type_traits/is_interval_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_container.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -9,29 +9,33 @@
#define __itl_type_traits_is_interval_container_JOFA_081004_H__
#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
namespace boost{ namespace itl
{
template <class Type> struct is_interval_container
{
typedef is_interval_container<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
template<class Type>
struct is_interval_map
{
typedef is_interval_map<Type> type;
- static const bool value =
- mpl::and_<is_interval_container<Type>, is_map<Type> >::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_<is_interval_container<Type>, is_map<Type> >::value)
+ );
};
template<class Type>
struct is_interval_set
{
typedef is_interval_set<Type> type;
- static const bool value =
- is_interval_container<Type>::value && !is_interval_map<Type>::value;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::and_< is_interval_container<Type>,
+ mpl::not_<is_interval_map<Type> > >::value)
+ );
};
Modified: sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -13,7 +13,7 @@
template <class Type> struct is_interval_separator
{
typedef is_interval_separator<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -13,7 +13,7 @@
template <class Type> struct is_interval_splitter
{
typedef is_interval_splitter<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_map.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_map.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -13,7 +13,7 @@
template <class Type> struct is_map
{
typedef is_map<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_set.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_set.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -13,7 +13,7 @@
template <class Type> struct is_set
{
typedef is_set<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_total.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_total.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_total.hpp 2009-09-06 12:16:24 EDT (Sun, 06 Sep 2009)
@@ -13,7 +13,7 @@
template <class Type> struct is_total
{
typedef is_total<Type> type;
- static const bool value = false;
+ BOOST_STATIC_CONSTANT(bool, value = false);
};
}} // namespace boost itl
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