return *this;
}
- any & operator=(const any & rhs)
+ any & operator=(any rhs)
{
- any(rhs).swap(*this);
+ rhs.swap(*this);
return *this;
}
//
// bind.hpp - binds function objects to arguments
//
-// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
-// Copyright (c) 2001 David Abrahams
-// Copyright (c) 2005 Peter Dimov
+// Copyright (c) 2009 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
-#include <boost/config.hpp>
-#include <boost/ref.hpp>
-#include <boost/mem_fn.hpp>
-#include <boost/type.hpp>
-#include <boost/is_placeholder.hpp>
-#include <boost/bind/arg.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/visit_each.hpp>
-
-// Borland-specific bug, visit_each() silently fails to produce code
-
-#if defined(__BORLANDC__)
-# define BOOST_BIND_VISIT_EACH boost::visit_each
-#else
-# define BOOST_BIND_VISIT_EACH visit_each
-#endif
-
-#include <boost/bind/storage.hpp>
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4512) // assignment operator could not be generated
-#endif
-
-namespace boost
-{
-
-namespace _bi // implementation details
-{
-
-// result_traits
-
-template<class R, class F> struct result_traits
-{
- typedef R type;
-};
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-struct unspecified {};
-
-template<class F> struct result_traits<unspecified, F>
-{
- typedef typename F::result_type type;
-};
-
-template<class F> struct result_traits< unspecified, reference_wrapper<F> >
-{
- typedef typename F::result_type type;
-};
-
-#endif
-
-// ref_compare
-
-template<class T> bool ref_compare( T const & a, T const & b, long )
-{
- return a == b;
-}
-
-template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
-{
- return true;
-}
-
-template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
-{
- return true;
-}
-
-template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
-{
- return a.get_pointer() == b.get_pointer();
-}
-
-// bind_t forward declaration for listN
-
-template<class R, class F, class L> class bind_t;
-
-// value
-
-template<class T> class value
-{
-public:
-
- value(T const & t): t_(t) {}
-
- T & get() { return t_; }
- T const & get() const { return t_; }
-
- bool operator==(value const & rhs) const
- {
- return t_ == rhs.t_;
- }
-
-private:
-
- T t_;
-};
-
-// type
-
-template<class T> class type {};
-
-// unwrap
-
-template<class F> struct unwrapper
-{
- static inline F & unwrap( F & f, long )
- {
- return f;
- }
-
- template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
- {
- return rf.get();
- }
-
- template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
- {
- return _mfi::dm<R, T>( pm );
- }
-};
-
-// listN
-
-class list0
-{
-public:
-
- list0() {}
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
- {
- return unwrapper<F>::unwrap(f, 0)();
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)();
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A &, int)
- {
- unwrapper<F>::unwrap(f, 0)();
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
- {
- unwrapper<F const>::unwrap(f, 0)();
- }
-
- template<class V> void accept(V &) const
- {
- }
-
- bool operator==(list0 const &) const
- {
- return true;
- }
-};
-
-template< class A1 > class list1: private storage1< A1 >
-{
-private:
-
- typedef storage1< A1 > base_type;
-
-public:
-
- explicit list1( A1 a1 ): base_type( a1 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-
- template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
-
- template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list1 const & rhs) const
- {
- return ref_compare(base_type::a1_, rhs.a1_, 0);
- }
-};
-
-struct logical_and;
-struct logical_or;
-
-template< class A1, class A2 > class list2: private storage2< A1, A2 >
-{
-private:
-
- typedef storage2< A1, A2 > base_type;
-
-public:
-
- list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
- }
-
- template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )
- {
- return a[ base_type::a1_ ] && a[ base_type::a2_ ];
- }
-
- template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const
- {
- return a[ base_type::a1_ ] && a[ base_type::a2_ ];
- }
-
- template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )
- {
- return a[ base_type::a1_ ] || a[ base_type::a2_ ];
- }
-
- template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const
- {
- return a[ base_type::a1_ ] || a[ base_type::a2_ ];
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list2 const & rhs) const
- {
- return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
- }
-};
-
-template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
-{
-private:
-
- typedef storage3< A1, A2, A3 > base_type;
-
-public:
-
- list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list3 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 );
- }
-};
-
-template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
-{
-private:
-
- typedef storage4< A1, A2, A3, A4 > base_type;
-
-public:
-
- list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list4 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
- ref_compare( base_type::a4_, rhs.a4_, 0 );
- }
-};
-
-template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
-{
-private:
-
- typedef storage5< A1, A2, A3, A4, A5 > base_type;
-
-public:
-
- list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list5 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
- ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
- ref_compare( base_type::a5_, rhs.a5_, 0 );
- }
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
-{
-private:
-
- typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
-
-public:
-
- list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list6 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
- ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
- ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
- ref_compare( base_type::a6_, rhs.a6_, 0 );
- }
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
-{
-private:
-
- typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
-
-public:
-
- list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
- A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
- A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list7 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
- ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
- ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
- ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
- ref_compare( base_type::a7_, rhs.a7_, 0 );
- }
-};
-
-template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
-{
-private:
-
- typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
-
-public:
-
- list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
- A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
- A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
- A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
- A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list8 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
- ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
- ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
- ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
- ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
- ref_compare( base_type::a8_, rhs.a8_, 0 );
- }
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
-{
-private:
-
- typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
-
-public:
-
- list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
-
- A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
- A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
- A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
- A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
-
- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
- A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
- A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
- A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
- A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
- A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
-
- template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
- template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
- template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
- {
- return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
- }
-
- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
- {
- return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
- }
-
- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
- {
- unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
- }
-
- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
- {
- unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
- }
-
- template<class V> void accept(V & v) const
- {
- base_type::accept(v);
- }
-
- bool operator==(list9 const & rhs) const
- {
- return
-
- ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
- ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
- ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
- ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
- ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
- ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
- ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
- ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
- ref_compare( base_type::a9_, rhs.a9_, 0 );
- }
-};
-
-// bind_t
-
-#ifndef BOOST_NO_VOID_RETURNS
-
-template<class R, class F, class L> class bind_t
-{
-public:
-
- typedef bind_t this_type;
-
- bind_t(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN return
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-#else
-
-template<class R> struct bind_t_generator
-{
-
-template<class F, class L> class implementation
-{
-public:
-
- typedef implementation this_type;
-
- implementation(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN return
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-};
-
-template<> struct bind_t_generator<void>
-{
-
-template<class F, class L> class implementation
-{
-private:
-
- typedef void R;
-
-public:
-
- typedef implementation this_type;
-
- implementation(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-};
-
-template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
-{
-public:
-
- bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
-
-};
-
-#endif
-
-// function_equal
-
-#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-
-// put overloads in _bi, rely on ADL
-
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
-{
- return a.compare(b);
-}
-
-# else
-
-template<class R, class F, class L> bool function_equal_impl( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
-{
- return a.compare(b);
-}
-
-# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-
-// put overloads in boost
-
-} // namespace _bi
-
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-template<class R, class F, class L> bool function_equal( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b )
-{
- return a.compare(b);
-}
-
-# else
-
-template<class R, class F, class L> bool function_equal_impl( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b, int )
-{
- return a.compare(b);
-}
-
-# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-namespace _bi
-{
-
-#endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-
-// add_value
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
-
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )
-
-template<class T> struct add_value
-{
- typedef _bi::value<T> type;
-};
-
-#else
-
-template< class T, int I > struct add_value_2
-{
- typedef boost::arg<I> type;
-};
-
-template< class T > struct add_value_2< T, 0 >
-{
- typedef _bi::value< T > type;
-};
-
-template<class T> struct add_value
-{
- typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
-};
-
-#endif
-
-template<class T> struct add_value< value<T> >
-{
- typedef _bi::value<T> type;
-};
-
-template<class T> struct add_value< reference_wrapper<T> >
-{
- typedef reference_wrapper<T> type;
-};
-
-template<int I> struct add_value< arg<I> >
-{
- typedef boost::arg<I> type;
-};
-
-template<int I> struct add_value< arg<I> (*) () >
-{
- typedef boost::arg<I> (*type) ();
-};
-
-template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
-{
- typedef bind_t<R, F, L> type;
-};
-
-#else
-
-template<int I> struct _avt_0;
-
-template<> struct _avt_0<1>
-{
- template<class T> struct inner
- {
- typedef T type;
- };
-};
-
-template<> struct _avt_0<2>
-{
- template<class T> struct inner
- {
- typedef value<T> type;
- };
-};
-
-typedef char (&_avt_r1) [1];
-typedef char (&_avt_r2) [2];
-
-template<class T> _avt_r1 _avt_f(value<T>);
-template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
-template<int I> _avt_r1 _avt_f(arg<I>);
-template<int I> _avt_r1 _avt_f(arg<I> (*) ());
-template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
-
-_avt_r2 _avt_f(...);
-
-template<class T> struct add_value
-{
- static T t();
- typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type;
-};
-
-#endif
-
-// list_av_N
-
-template<class A1> struct list_av_1
-{
- typedef typename add_value<A1>::type B1;
- typedef list1<B1> type;
-};
-
-template<class A1, class A2> struct list_av_2
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef list2<B1, B2> type;
-};
-
-template<class A1, class A2, class A3> struct list_av_3
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef list3<B1, B2, B3> type;
-};
-
-template<class A1, class A2, class A3, class A4> struct list_av_4
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef typename add_value<A4>::type B4;
- typedef list4<B1, B2, B3, B4> type;
-};
-
-template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef typename add_value<A4>::type B4;
- typedef typename add_value<A5>::type B5;
- typedef list5<B1, B2, B3, B4, B5> type;
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef typename add_value<A4>::type B4;
- typedef typename add_value<A5>::type B5;
- typedef typename add_value<A6>::type B6;
- typedef list6<B1, B2, B3, B4, B5, B6> type;
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef typename add_value<A4>::type B4;
- typedef typename add_value<A5>::type B5;
- typedef typename add_value<A6>::type B6;
- typedef typename add_value<A7>::type B7;
- typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef typename add_value<A4>::type B4;
- typedef typename add_value<A5>::type B5;
- typedef typename add_value<A6>::type B6;
- typedef typename add_value<A7>::type B7;
- typedef typename add_value<A8>::type B8;
- typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
-};
-
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
-{
- typedef typename add_value<A1>::type B1;
- typedef typename add_value<A2>::type B2;
- typedef typename add_value<A3>::type B3;
- typedef typename add_value<A4>::type B4;
- typedef typename add_value<A5>::type B5;
- typedef typename add_value<A6>::type B6;
- typedef typename add_value<A7>::type B7;
- typedef typename add_value<A8>::type B8;
- typedef typename add_value<A9>::type B9;
- typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
-};
-
-// operator!
-
-struct logical_not
-{
- template<class V> bool operator()(V const & v) const { return !v; }
-};
-
-template<class R, class F, class L>
- bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
- operator! (bind_t<R, F, L> const & f)
-{
- typedef list1< bind_t<R, F, L> > list_type;
- return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
-}
-
-// relational operators
-
-#define BOOST_BIND_OPERATOR( op, name ) \
-\
-struct name \
-{ \
- template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
-}; \
- \
-template<class R, class F, class L, class A2> \
- bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \
- operator op (bind_t<R, F, L> const & f, A2 a2) \
-{ \
- typedef typename add_value<A2>::type B2; \
- typedef list2< bind_t<R, F, L>, B2> list_type; \
- return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
-}
-
-BOOST_BIND_OPERATOR( ==, equal )
-BOOST_BIND_OPERATOR( !=, not_equal )
-
-BOOST_BIND_OPERATOR( <, less )
-BOOST_BIND_OPERATOR( <=, less_equal )
-
-BOOST_BIND_OPERATOR( >, greater )
-BOOST_BIND_OPERATOR( >=, greater_equal )
-
-BOOST_BIND_OPERATOR( &&, logical_and )
-BOOST_BIND_OPERATOR( ||, logical_or )
-
-#undef BOOST_BIND_OPERATOR
-
-#if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
-
-// resolve ambiguity with rel_ops
-
-#define BOOST_BIND_OPERATOR( op, name ) \
-\
-template<class R, class F, class L> \
- bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
- operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \
-{ \
- typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \
- return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
-}
-
-BOOST_BIND_OPERATOR( !=, not_equal )
-BOOST_BIND_OPERATOR( <=, less_equal )
-BOOST_BIND_OPERATOR( >, greater )
-BOOST_BIND_OPERATOR( >=, greater_equal )
-
-#endif
-
-// visit_each, ADL
-
-#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
- && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-
-template<class V, class T> void visit_each( V & v, value<T> const & t, int )
-{
- using boost::visit_each;
- BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
-}
-
-template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
-{
- t.accept( v );
-}
-
-#endif
-
-} // namespace _bi
-
-// visit_each, no ADL
-
-#if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
- || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-
-template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
-{
- BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
-}
-
-template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
-{
- t.accept( v );
-}
-
-#endif
-
-// is_bind_expression
-
-template< class T > struct is_bind_expression
-{
- enum _vt { value = 0 };
-};
-
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
-template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
-{
- enum _vt { value = 1 };
-};
-
-#endif
-
-// bind
-
-#ifndef BOOST_BIND
-#define BOOST_BIND bind
-#endif
-
-// generic function objects
-
-template<class R, class F>
- _bi::bind_t<R, F, _bi::list0>
- BOOST_BIND(F f)
-{
- typedef _bi::list0 list_type;
- return _bi::bind_t<R, F, list_type> (f, list_type());
-}
-
-template<class R, class F, class A1>
- _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
- BOOST_BIND(F f, A1 a1)
-{
- typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t<R, F, list_type> (f, list_type(a1));
-}
-
-template<class R, class F, class A1, class A2>
- _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
- BOOST_BIND(F f, A1 a1, A2 a2)
-{
- typedef typename _bi::list_av_2<A1, A2>::type list_type;
- return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
-}
-
-template<class R, class F, class A1, class A2, class A3>
- _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
-{
- typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4>
- _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
-{
- typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5>
- _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
- typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
- _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
- typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
- _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
- typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
- _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
- typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
- _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
- typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-// generic function objects, alternative syntax
-
-template<class R, class F>
- _bi::bind_t<R, F, _bi::list0>
- BOOST_BIND(boost::type<R>, F f)
-{
- typedef _bi::list0 list_type;
- return _bi::bind_t<R, F, list_type> (f, list_type());
-}
-
-template<class R, class F, class A1>
- _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1)
-{
- typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t<R, F, list_type> (f, list_type(a1));
-}
-
-template<class R, class F, class A1, class A2>
- _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
-{
- typedef typename _bi::list_av_2<A1, A2>::type list_type;
- return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
-}
-
-template<class R, class F, class A1, class A2, class A3>
- _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
-{
- typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4>
- _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
-{
- typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5>
- _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
- typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
- _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
- typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
- _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
- typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
- _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
- typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
- _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
- BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
- typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
- return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-// adaptable function objects
-
-template<class F>
- _bi::bind_t<_bi::unspecified, F, _bi::list0>
- BOOST_BIND(F f)
-{
- typedef _bi::list0 list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
-}
-
-template<class F, class A1>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
- BOOST_BIND(F f, A1 a1)
-{
- typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
-}
-
-template<class F, class A1, class A2>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
- BOOST_BIND(F f, A1 a1, A2 a2)
-{
- typedef typename _bi::list_av_2<A1, A2>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
-}
-
-template<class F, class A1, class A2, class A3>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
-{
- typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
-}
-
-template<class F, class A1, class A2, class A3, class A4>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
-{
- typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
-}
-
-template<class F, class A1, class A2, class A3, class A4, class A5>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
- typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
-}
-
-template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
- typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
-}
-
-template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
- typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
- typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
- _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
- BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
- typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
- return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-// function pointers
-
-#define BOOST_BIND_CC
-#define BOOST_BIND_ST
-
-#include <boost/bind/bind_cc.hpp>
-
-#undef BOOST_BIND_CC
-#undef BOOST_BIND_ST
-
-#ifdef BOOST_BIND_ENABLE_STDCALL
-
-#define BOOST_BIND_CC __stdcall
-#define BOOST_BIND_ST
-
-#include <boost/bind/bind_cc.hpp>
-
-#undef BOOST_BIND_CC
-#undef BOOST_BIND_ST
-
-#endif
-
-#ifdef BOOST_BIND_ENABLE_FASTCALL
-
-#define BOOST_BIND_CC __fastcall
-#define BOOST_BIND_ST
-
-#include <boost/bind/bind_cc.hpp>
-
-#undef BOOST_BIND_CC
-#undef BOOST_BIND_ST
-
-#endif
-
-#ifdef BOOST_BIND_ENABLE_PASCAL
-
-#define BOOST_BIND_ST pascal
-#define BOOST_BIND_CC
-
-#include <boost/bind/bind_cc.hpp>
-
-#undef BOOST_BIND_ST
-#undef BOOST_BIND_CC
-
-#endif
-
-// member function pointers
-
-#define BOOST_BIND_MF_NAME(X) X
-#define BOOST_BIND_MF_CC
-
-#include <boost/bind/bind_mf_cc.hpp>
-#include <boost/bind/bind_mf2_cc.hpp>
-
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_BIND_MF_NAME(X) X##_cdecl
-#define BOOST_BIND_MF_CC __cdecl
-
-#include <boost/bind/bind_mf_cc.hpp>
-#include <boost/bind/bind_mf2_cc.hpp>
-
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_BIND_MF_NAME(X) X##_stdcall
-#define BOOST_BIND_MF_CC __stdcall
-
-#include <boost/bind/bind_mf_cc.hpp>
-#include <boost/bind/bind_mf2_cc.hpp>
-
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_BIND_MF_NAME(X) X##_fastcall
-#define BOOST_BIND_MF_CC __fastcall
-
-#include <boost/bind/bind_mf_cc.hpp>
-#include <boost/bind/bind_mf2_cc.hpp>
-
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
-
-#endif
-
-// data member pointers
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x600 ) )
-
-template<class R, class T, class A1>
-_bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
- BOOST_BIND(R T::*f, A1 a1)
-{
- typedef _mfi::dm<R, T> F;
- typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
-}
-
-#else
-
-namespace _bi
-{
-
-template< class Pm, int I > struct add_cref;
-
-template< class M, class T > struct add_cref< M T::*, 0 >
-{
- typedef M type;
-};
-
-template< class M, class T > struct add_cref< M T::*, 1 >
-{
- typedef M const & type;
-};
-
-template< class R, class T > struct add_cref< R (T::*) (), 1 >
-{
- typedef void type;
-};
-
-#if !( defined(__IBMCPP__) && BOOST_WORKAROUND( __IBMCPP__, BOOST_TESTED_AT(600) ) )
-
-template< class R, class T > struct add_cref< R (T::*) () const, 1 >
-{
- typedef void type;
-};
-
-#endif // __IBMCPP__
-
-template<class R> struct isref
-{
- enum value_type { value = 0 };
-};
-
-template<class R> struct isref< R& >
-{
- enum value_type { value = 1 };
-};
-
-template<class R> struct isref< R* >
-{
- enum value_type { value = 1 };
-};
-
-template<class Pm, class A1> struct dm_result
-{
- typedef typename add_cref< Pm, 1 >::type type;
-};
-
-template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
-{
- typedef typename bind_t<R, F, L>::result_type result_type;
- typedef typename add_cref< Pm, isref< result_type >::value >::type type;
-};
-
-} // namespace _bi
-
-template< class A1, class M, class T >
-
-_bi::bind_t<
- typename _bi::dm_result< M T::*, A1 >::type,
- _mfi::dm<M, T>,
- typename _bi::list_av_1<A1>::type
->
-
-BOOST_BIND( M T::*f, A1 a1 )
-{
- typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
- typedef _mfi::dm<M, T> F;
- typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
-}
-
-#endif
-
-} // namespace boost
-
-#ifndef BOOST_BIND_NO_PLACEHOLDERS
-
-# include <boost/bind/placeholders.hpp>
-
-#endif
-
-#ifdef BOOST_MSVC
-# pragma warning(default: 4512) // assignment operator could not be generated
-# pragma warning(pop)
-#endif
+#include <boost/bind/bind.hpp>
#endif // #ifndef BOOST_BIND_HPP_INCLUDED
// 0
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class A1>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class A1>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}
// 1
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1,
class A1, class A2>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1,
class A1, class A2>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}
// 2
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2,
class A1, class A2, class A3>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2,
class A1, class A2, class A3>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}
// 3
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
// 4
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
// 5
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
// 6
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
// 7
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
// 8
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
-template<class R2, class R, class T,
+template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
- _bi::bind_t<R2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
- BOOST_BIND(boost::type<R2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+ _bi::bind_t<R
t2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+ BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
- return _bi::bind_t<R2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
namespace
{
-#if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ <= 400)
+#if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 400)
static inline boost::arg<1> _1() { return boost::arg<1>(); }
static inline boost::arg<2> _2() { return boost::arg<2>(); }
static inline boost::arg<8> _8() { return boost::arg<8>(); }
static inline boost::arg<9> _9() { return boost::arg<9>(); }
-#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
+#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) || \
+ defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ == 400)
static boost::arg<1> _1;
static boost::arg<2> _2;
void const_constraints(const TT& b) {
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
a = b; // const required for argument to assignment
+#else
+ ignore_unused_variable_warning(b);
#endif
}
private:
TT b;
};
+#if (defined _MSC_VER)
+# pragma warning( push )
+# pragma warning( disable : 4510 ) // default constructor could not be generated
+# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
+#endif
// The SGI STL version of Assignable requires copy constructor and operator=
BOOST_concept(SGIAssignable,(TT))
{
}
TT a;
};
+#if (defined _MSC_VER)
+# pragma warning( pop )
+#endif
BOOST_concept(Convertible,(X)(Y))
{
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#pragma pack(push,8)
+//
+// Boost binaries are built with the compiler's default ABI settings,
+// if the user changes their default alignment in the VS IDE then their
+// code will no longer be binary compatible with the bjam built binaries
+// unless this header is included to force Boost code into a consistent ABI.
+//
+// Note that inclusion of this header is only necessary for libraries with
+// separate source, header only libraries DO NOT need this as long as all
+// translation units are built with the same options.
+//
+#if defined(_M_X64)
+# pragma pack(push,16)
+#else
+# pragma pack(push,8)
+#endif
// vc80:
# define BOOST_LIB_TOOLSET "vc80"
-#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1500)
+#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1500)
// vc90:
# define BOOST_LIB_TOOLSET "vc90"
+#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)
+
+ // vc10:
+# define BOOST_LIB_TOOLSET "vc100"
+
#elif defined(__BORLANDC__)
// CBuilder 6:
# error "Compiler not supported or configured - please reconfigure"
#endif
-// last known and checked version is 0x600 (Builder X preview)
-// or 0x593 (CodeGear C++ Builder 2007 December 2007 update):
-#if (__BORLANDC__ > 0x593) && (__BORLANDC__ != 0x600)
-# if defined(BOOST_ASSERT_CONFIG)
+// last known compiler version:
+#if (__BORLANDC__ > 0x610)
+//# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
-# else
-# pragma message( "Unknown compiler version - please run the configure tests and report the results")
-# endif
+//# else
+//# pragma message( "Unknown compiler version - please run the configure tests and report the results")
+//# endif
+#elif (__BORLANDC__ == 0x600)
+# error "CBuilderX preview compiler is no longer supported"
#endif
//
#endif
// Borland C++ Builder 2007 December 2007 Update and below:
-#if (__BORLANDC__ <= 0x593)
-# define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
-# define BOOST_NO_USING_TEMPLATE
-# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
-# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+//#if (__BORLANDC__ <= 0x593)
+#if (__BORLANDC__ <= 0x610) // Beman has asked Alisdair for more info
// we shouldn't really need this - but too many things choke
// without it, this needs more investigation:
# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
# define BOOST_NO_IS_ABSTRACT
# define BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
-# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
// Temporary workaround
#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif
+// Borland C++ Builder 2008 and below:
+#if (__BORLANDC__ <= 0x601)
+# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+# define BOOST_ILLEGAL_CV_REFERENCES
+# define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
+# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+# define BOOST_NO_USING_TEMPLATE
+# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
#endif
+//
+// Positive Feature detection
+//
+// Borland C++ Builder 2008 and below:
+#if (__BORLANDC__ >= 0x599)
+# pragma defineonoption BOOST_CODEGEAR_0X_SUPPORT -Ax
+#endif
+//
+// C++0x Macros:
+//
+#if defined( BOOST_CODEGEAR_0X_SUPPORT ) && (__BORLANDC__ >= 0x610)
+# define BOOST_HAS_ALIGNOF
+# define BOOST_HAS_CHAR16_T
+# define BOOST_HAS_CHAR32_T
+# define BOOST_HAS_DECLTYPE
+# define BOOST_HAS_EXPLICIT_CONVERSION_OPS
+# define BOOST_HAS_REF_QUALIFIER
+# define BOOST_HAS_RVALUE_REFS
+# define BOOST_HAS_STATIC_ASSERT
+
+# define BOOST_NO_EXTERN_TEMPLATE
+# define BOOST_NO_SCOPED_ENUMS
+# define BOOST_NO_VARIADIC_TEMPLATES
+# define BOOST_NO_CONSTEXPR
+# define BOOST_NO_DEFAULTED_FUNCTIONS
+# define BOOST_NO_DELETED_FUNCTIONS
+# define BOOST_NO_RAW_LITERALS
+# define BOOST_NO_UNICODE_LITERALS // UTF-8 still not supported
+#else
+# define BOOST_NO_CHAR16_T
+# define BOOST_NO_CHAR32_T
+# define BOOST_NO_DECLTYPE
+# define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+# define BOOST_NO_EXTERN_TEMPLATE
+# define BOOST_NO_SCOPED_ENUMS
+# define BOOST_NO_STATIC_ASSERT
+# define BOOST_NO_RVALUE_REFERENCES
+# define BOOST_NO_VARIADIC_TEMPLATES
+# define BOOST_NO_CONSTEXPR
+# define BOOST_NO_DEFAULTED_FUNCTIONS
+# define BOOST_NO_DELETED_FUNCTIONS
+# define BOOST_NO_RAW_LITERALS
+# define BOOST_NO_UNICODE_LITERALS
+#endif
+
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_INITIALIZER_LISTS
+
#if __BORLANDC__ >= 0x590
# define BOOST_HAS_TR1_HASH
#if __BORLANDC__ >= 0x561
# ifndef __NO_LONG_LONG
# define BOOST_HAS_LONG_LONG
+# else
+# define BOOST_NO_LONG_LONG
# endif
// On non-Win32 platforms let the platform config figure this out:
# ifdef _WIN32
#define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)
+
# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#endif
+#if (__EDG_VERSION__ <= 310) || !defined(BOOST_STRICT_CONFIG)
+// No support for initializer lists
+# define BOOST_NO_INITIALIZER_LISTS
+#endif
+
// See also kai.hpp which checks a Kai-specific symbol for EH
# if !defined(__KCC) && !defined(__EXCEPTIONS)
# define BOOST_NO_EXCEPTIONS
# if !defined(__NO_LONG_LONG)
# define BOOST_HAS_LONG_LONG
+# else
+# define BOOST_NO_LONG_LONG
# endif
+//
+// C++0x features
+//
+// See above for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
#ifdef c_plusplus
// EDG has "long long" in non-strict mode
// However, some libraries have insufficient "long long" support
#if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 )
#define BOOST_HAS_NRVO
#endif
-
//
-// C++0x features
+// RTTI and typeinfo detection is possible post gcc-4.3:
//
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)
-// C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
-// passed on the command line, which in turn defines
-// __GXX_EXPERIMENTAL_CXX0X__.
-# if defined(__GXX_EXPERIMENTAL_CXX0X__)
-# define BOOST_HAS_STATIC_ASSERT
-# define BOOST_HAS_VARIADIC_TMPL
-# define BOOST_HAS_RVALUE_REFS
-# define BOOST_HAS_DECLTYPE
+#if __GNUC__ * 100 + __GNUC_MINOR__ >= 403
+# ifndef __GXX_RTTI
+# define BOOST_NO_TYPEID
+# define BOOST_NO_RTTI
# endif
#endif
//
-// Potential C++0x features
+// C++0x features
//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_UNICODE_LITERALS
+// See below for BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && defined(__GXX_EXPERIMENTAL_CXX0X__)
+// C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
+// passed on the command line, which in turn defines
+// __GXX_EXPERIMENTAL_CXX0X__.
+# define BOOST_HAS_DECLTYPE
+# define BOOST_HAS_RVALUE_REFS
+# define BOOST_HAS_STATIC_ASSERT
+# define BOOST_HAS_VARIADIC_TMPL
+#else
+# define BOOST_NO_DECLTYPE
+# define BOOST_NO_RVALUE_REFERENCES
+# define BOOST_NO_STATIC_ASSERT
+
// Variadic templates compiler:
// http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html
-#ifdef __VARIADIC_TEMPLATES
-# define BOOST_HAS_VARIADIC_TMPL
+# ifdef __VARIADIC_TEMPLATES
+# define BOOST_HAS_VARIADIC_TMPL
+# else
+# define BOOST_NO_VARIADIC_TEMPLATES
+# endif
+#endif
+
+#if !defined(__GXX_EXPERIMENTAL_CXX0X__) || __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4)
+# define BOOST_NO_INITIALIZER_LISTS
+# define BOOST_NO_AUTO_DECLARATIONS
#endif
// ConceptGCC compiler:
# endif //PA-RISC
#endif
+//
+// C++0x features
+//
+// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+
//
// last known and checked version for HP-UX/ia64 is 61300
// last known and checked version for PA-RISC is 38000
# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
# endif
#endif
-#if (defined(__GNUC__) && (__GNUC__ < 4)) || defined(_WIN32)
+#if (defined(__GNUC__) && (__GNUC__ < 4)) || defined(_WIN32) || (BOOST_INTEL_CXX_VERSION <= 1100)
// GCC or VC emulation:
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif
# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif
+// Intel on Altix Itanium
+#if defined(__itanium__) && defined(__INTEL_COMPILER)
+# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
+
+//
+// C++0x features
+//
+// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+
//
// last known and checked version:
-#if (BOOST_INTEL_CXX_VERSION > 1010)
+#if (BOOST_INTEL_CXX_VERSION > 1100)
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
# elif defined(_MSC_VER)
# if(__MWERKS__ <= 0x3206) || !defined(BOOST_STRICT_CONFIG) // 9.5
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
# define BOOST_NO_IS_ABSTRACT
+# define BOOST_NO_INITIALIZER_LISTS
# endif
#if !__option(wchar_type)
//
// C++0x features
//
+// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
#if __MWERKS__ > 0x3206 && __option(rvalue_refs)
# define BOOST_HAS_RVALUE_REFS
+#else
+# define BOOST_NO_RVALUE_REFERENCES
#endif
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
# define BOOST_NO_STD_ALLOCATOR /* actually a bug with const reference overloading */
+
+# define BOOST_NO_INITIALIZER_LISTS
#endif
+//
+// C++0x features
+//
+// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+
//
// versions check:
// we don't support MPW prior to version 8.9:
#undef BOOST_NO_SWPRINTF
#undef BOOST_DEDUCED_TYPENAME
+
+#define BOOST_NO_INITIALIZER_LISTS
+//
+// C++0x features
+//
+// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+
//
// version check:
// probably nothing to do here?
//
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#define BOOST_NO_ADL_BARRIER
+#define BOOST_NO_INITIALIZER_LISTS
+//
+// C++0x features
+//
+
+#if(__SUNPRO_CC >= 0x590)
+# define BOOST_HAS_LONG_LONG
+#else
+# define BOOST_NO_LONG_LONG
+#endif
+
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+
+//
+// Version
+//
#define BOOST_COMPILER "Sun compiler version " BOOST_STRINGIZE(__SUNPRO_CC)
# error "Unknown compiler version - please run the configure tests and report the results"
# endif
#endif
-
-
-
-
-
-
#if (__IBMCPP__ <= 600) || !defined(BOOST_STRICT_CONFIG)
# define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
+# define BOOST_NO_INITIALIZER_LISTS
#endif
//
// Some versions of the compiler have issues with default arguments on partial specializations
#define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+//
+// C++0x features
+//
+// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
# define BOOST_NO_VOID_RETURNS
# define BOOST_NO_EXCEPTION_STD_NAMESPACE
+
+# if BOOST_MSVC == 1202
+# define BOOST_NO_STD_TYPEINFO
+# endif
+
// disable min/max macro defines on vc6:
//
#endif
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#endif
-#if _MSC_VER <= 1500 // 1500 == VC++ 9.0
+#if _MSC_VER <= 1600 // 1600 == VC++ 10.0
# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif
# define BOOST_NO_ADL_BARRIER
#endif
+#if _MSC_VER <= 1500 || !defined(BOOST_STRICT_CONFIG) // 1500 == VC++ 9.0
+# define BOOST_NO_INITIALIZER_LISTS
+#endif
+
#ifndef _NATIVE_WCHAR_T_DEFINED
# define BOOST_NO_INTRINSIC_WCHAR_T
#endif
#endif
#if (_MSC_VER >= 1310) && defined(_MSC_EXTENSIONS)
# define BOOST_HAS_LONG_LONG
+#else
+# define BOOST_NO_LONG_LONG
#endif
#if (_MSC_VER >= 1400) && !defined(_DEBUG)
# define BOOST_HAS_NRVO
#ifndef _MSC_EXTENSIONS
# define BOOST_DISABLE_WIN32
#endif
+#ifndef _CPPRTTI
+# define BOOST_NO_RTTI
+#endif
//
// all versions support __declspec:
//
#define BOOST_HAS_DECLSPEC
+//
+// C++0x features
+//
+// See above for BOOST_NO_LONG_LONG
+#define BOOST_NO_CHAR16_T
+#define BOOST_NO_CHAR32_T
+#define BOOST_NO_CONSTEXPR
+#define BOOST_NO_DECLTYPE
+#define BOOST_NO_DEFAULTED_FUNCTIONS
+#define BOOST_NO_DELETED_FUNCTIONS
+#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_EXTERN_TEMPLATE
+#define BOOST_NO_RAW_LITERALS
+#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_UNICODE_LITERALS
+#define BOOST_NO_VARIADIC_TEMPLATES
+
+// MSVC 2010 CTP has some support for C++0x, but we still disable it until the compiler release
+// #if _MSC_VER < 1600
+#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_AUTO_DECLARATIONS
+#define BOOST_NO_AUTO_MULTIDECLARATIONS
+// #endif // _MSC_VER < 1600
+
//
// prefix and suffix headers:
//
# define BOOST_COMPILER_VERSION evc4.0
# elif _MSC_VER == 1400
# define BOOST_COMPILER_VERSION evc8
+# elif _MSC_VER == 1500
+# define BOOST_COMPILER_VERSION evc9
+# elif _MSC_VER == 1600
+# define BOOST_COMPILER_VERSION evc10
# else
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown EVC++ compiler version - please run the configure tests and report the results"
# define BOOST_COMPILER_VERSION 8.0
# elif _MSC_VER == 1500
# define BOOST_COMPILER_VERSION 9.0
+# elif _MSC_VER == 1600
+# define BOOST_COMPILER_VERSION 10.0
# else
# define BOOST_COMPILER_VERSION _MSC_VER
# endif
#endif
//
// last known and checked version is 1500 (VC9):
-#if (_MSC_VER > 1500)
+#if (_MSC_VER > 1600)
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
# else
// FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in <pthread.h>
// and not in <unistd.h>
//
-#if (defined(__FreeBSD__) && (__FreeBSD__ <= 3)) || defined(__OpenBSD__)
+#if (defined(__FreeBSD__) && (__FreeBSD__ <= 3))\
+ || defined(__OpenBSD__) || defined(__DragonFly__)
# define BOOST_HAS_PTHREADS
#endif
//
// No wide character support in the BSD header files:
//
-#if !(defined(__FreeBSD__) && (__FreeBSD__ >= 5))
+#if defined(__NetBSD__)
+#define __NetBSD_GCC__ (__GNUC__ * 1000000 \
+ + __GNUC_MINOR__ * 1000 \
+ + __GNUC_PATCHLEVEL__)
+// XXX - the following is required until c++config.h
+// defines _GLIBCXX_HAVE_SWPRINTF and friends
+// or the preprocessor conditionals are removed
+// from the cwchar header.
+#define _GLIBCXX_HAVE_SWPRINTF 1
+#endif
+
+#if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
+ || (__NetBSD_GCC__ >= 2095003) || defined(__DragonFly__))
# define BOOST_NO_CWCHAR
#endif
//
// The BSD <ctype.h> has macros only, no functions:
//
-#if !defined(__OpenBSD__)
+#if !defined(__OpenBSD__) || defined(__DragonFly__)
# define BOOST_NO_CTYPE_FUNCTIONS
#endif
// Greenhills C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp"
+#elif defined __CODEGEARC__
+// CodeGear - must be checked for before Borland
+# define BOOST_COMPILER_CONFIG "boost/config/compiler/codegear.hpp"
+
#elif defined __BORLANDC__
// Borland
# define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp"
// <header_name> in order to prevent macro expansion within the header
// name (for example "linux" is a macro on linux systems).
-#if defined(linux) || defined(__linux) || defined(__linux__)
-// linux:
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
+// linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though?
# define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
# define BOOST_NO_STD_ITERATOR_TRAITS
#endif
+//
+// No std::unordered_* containers yet:
+//
+#define BOOST_NO_STD_UNORDERED
+
#if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310)
// Intel C++ chokes over any non-trivial use of <locale>
// this may be an overly restrictive define, but regex fails without it:
# define BOOST_HAS_HASH
# define BOOST_HAS_SLIST
#endif
+//
+// We never have the new C++0x unordered containers:
+//
+#define BOOST_NO_STD_UNORDERED
//
// Intrinsic type_traits support.
# define BOOST_HASH_MAP_HEADER <backward/hash_map>
# endif
#endif
+
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+# define BOOST_NO_STD_UNORDERED
+#endif
+
#ifndef MSIPL_WCHART
#define BOOST_NO_STD_WSTRING
#endif
+//
+// We never have the new C++0x unordered containers:
+//
+#define BOOST_NO_STD_UNORDERED
#define BOOST_STDLIB "Modena C++ standard library"
# define BOOST_NO_STD_USE_FACET
# define BOOST_HAS_TWO_ARG_USE_FACET
#endif
+//
+// We never have the new C++0x unordered containers:
+//
+#define BOOST_NO_STD_UNORDERED
#define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
# define _HP_INSTANTIATE_STD2_VL
# endif
#endif
+
+//
+// We never have the new C++0x unordered containers:
+//
+#define BOOST_NO_STD_UNORDERED
+
//
#define BOOST_HAS_HASH
#define BOOST_HAS_SLIST
+#define BOOST_NO_STD_UNORDERED
//
// If this is GNU libstdc++2, then no <limits> and no std::wstring:
// STLPort standard library config:
#if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-# include <boost/config/no_tr1/utility.hpp>
+# include <cstddef>
# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
# error "This is not STLPort!"
# endif
# endif
#endif
+#if defined(_STLPORT_VERSION) && (_STLPORT_VERSION < 0x500)
+# define BOOST_NO_STD_UNORDERED
+#endif
//
// Without member template support enabled, their are no template
// iterate constructors, and no std::allocator:
#define BOOST_HAS_MACRO_USE_FACET
#define BOOST_NO_STD_MESSAGES
+#define BOOST_NO_STD_UNORDERED
#define BOOST_STDLIB "Visual Age default standard library"
// Boost config.hpp configuration header file ------------------------------//
-// (C) Copyright John Maddock 2001 - 2003.
-// (C) Copyright Darin Adler 2001.
-// (C) Copyright Peter Dimov 2001.
-// (C) Copyright Bill Kempf 2002.
-// (C) Copyright Jens Maurer 2002.
-// (C) Copyright David Abrahams 2002 - 2003.
-// (C) Copyright Gennaro Prota 2003.
-// (C) Copyright Eric Friedman 2003.
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
+// Copyright (c) 2001-2003 John Maddock
+// Copyright (c) 2001 Darin Adler
+// Copyright (c) 2001 Peter Dimov
+// Copyright (c) 2002 Bill Kempf
+// Copyright (c) 2002 Jens Maurer
+// Copyright (c) 2002-2003 David Abrahams
+// Copyright (c) 2003 Gennaro Prota
+// Copyright (c) 2003 Eric Friedman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org/ for most recent version.
// Boost config.hpp policy and rationale documentation has been moved to
-// http://www.boost.org/libs/config
+// http://www.boost.org/libs/config/
//
// This file is intended to be stable, and relatively unchanging.
// It should contain boilerplate code only - no compiler specific
// remember that since these just declare a bunch of macros, there should be
// no namespace issues from this.
//
-#if !defined(BOOST_HAS_LONG_LONG) \
+#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG) \
&& !defined(BOOST_MSVC) && !defined(__BORLANDC__)
# include <limits.h>
# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
# define BOOST_HAS_LONG_LONG
+# else
+# define BOOST_NO_LONG_LONG
# endif
#endif
# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#endif
+//
+// Without typeid support we have no dynamic RTTI either:
+//
+#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
+# define BOOST_NO_RTTI
+#endif
+
//
// If we have a standard allocator, then we have a partial one as well:
//
// from here then add to the appropriate compiler section):
//
#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
- || defined(_PTHREADS)) && !defined(BOOST_HAS_THREADS)
+ || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \
+ && !defined(BOOST_HAS_THREADS)
# define BOOST_HAS_THREADS
#endif
// Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
// Note that this is for backwards compatibility only.
//
-# ifndef BOOST_HAS_SLIST
+# if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST)
# define BOOST_NO_SLIST
# endif
-# ifndef BOOST_HAS_HASH
+# if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH)
# define BOOST_NO_HASH
# endif
// with
// BOOST_USE_FACET(Type, loc);
// Note do not add a std:: prefix to the front of BOOST_USE_FACET!
-// Use for BOOST_HAS_FACET is analagous.
+// Use for BOOST_HAS_FACET is analogous.
#if defined(BOOST_NO_STD_USE_FACET)
# ifdef BOOST_HAS_TWO_ARG_USE_FACET
# define BOOST_DEDUCED_TYPENAME
#endif
+#ifndef BOOST_NO_TYPENAME_WITH_CTOR
+# define BOOST_CTOR_TYPENAME typename
+#else
+# define BOOST_CTOR_TYPENAME
+#endif
+
// long long workaround ------------------------------------------//
// On gcc (and maybe other compilers?) long long is alway supported
// but it's use may generate either warnings (with -ansi), or errors
// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
//
-// Some compilers have problems with function templates whose
-// template parameters don't appear in the function parameter
-// list (basically they just link one instantiation of the
-// template in the final executable). These macros provide a
-// uniform way to cope with the problem with no effects on the
-// calling syntax.
+// Some compilers have problems with function templates whose template
+// parameters don't appear in the function parameter list (basically
+// they just link one instantiation of the template in the final
+// executable). These macros provide a uniform way to cope with the
+// problem with no effects on the calling syntax.
// Example:
//
# include "boost/type.hpp"
# include "boost/non_type.hpp"
-# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type<t>* = 0
-# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type<t>*
-# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type<t, v>* = 0
+# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type<t>* = 0
+# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type<t>*
+# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type<t, v>* = 0
# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type<t, v>*
-# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \
+# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \
, BOOST_EXPLICIT_TEMPLATE_TYPE(t)
-# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \
+# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \
, BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
-# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
+# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
, BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
-# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \
+# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \
, BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
#else
// this is triggered with GCC, because it defines __cplusplus < 199707L
# define BOOST_NO_INT64_T
# endif
-# elif defined(__FreeBSD__) || defined(__IBMCPP__)
+# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
# include <inttypes.h>
# else
# include <stdint.h>
//
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// typedef <implementation-defined> boost::detail::atomic_count;
-//
-// atomic_count a(n);
-//
-// (n is convertible to long)
-//
-// Effects: Constructs an atomic_count with an initial value of n
-//
-// a;
-//
-// Returns: (long) the current value of a
-//
-// ++a;
-//
-// Effects: Atomically increments the value of a
-// Returns: nothing
-//
-// --a;
-//
-// Effects: Atomically decrements the value of a
-// Returns: (long) zero if the new value of a is zero,
-// unspecified non-zero value otherwise (usually the new value)
-//
-// Important note: when --a returns zero, it must act as a
-// read memory barrier (RMB); i.e. the calling thread must
-// have a synchronized view of the memory
-//
-// On Intel IA-32 (x86) memory is always synchronized, so this
-// is not a problem.
-//
-// On many architectures the atomic instructions already act as
-// a memory barrier.
-//
-// This property is necessary for proper reference counting, since
-// a thread can update the contents of a shared object, then
-// release its reference, and another thread may immediately
-// release the last reference causing object destruction.
-//
-// The destructor needs to have a synchronized view of the
-// object to perform proper cleanup.
-//
-// Original example by Alexander Terekhov:
-//
-// Given:
-//
-// - a mutable shared object OBJ;
-// - two threads THREAD1 and THREAD2 each holding
-// a private smart_ptr object pointing to that OBJ.
-//
-// t1: THREAD1 updates OBJ (thread-safe via some synchronization)
-// and a few cycles later (after "unlock") destroys smart_ptr;
-//
-// t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization
-// with respect to shared mutable object OBJ; OBJ destructors
-// are called driven by smart_ptr interface...
-//
-
-#include <boost/config.hpp>
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
-#ifndef BOOST_HAS_THREADS
-
-namespace boost
-{
-
-namespace detail
-{
-
-typedef long atomic_count;
-
-}
-
-}
-
-#elif defined(BOOST_AC_USE_PTHREADS)
-
-# include <boost/detail/atomic_count_pthreads.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-
-# include <boost/detail/atomic_count_gcc_x86.hpp>
-
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-
-# include <boost/detail/atomic_count_win32.hpp>
-
-#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
-
-# include <boost/detail/atomic_count_sync.hpp>
-
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-
-# include <boost/detail/atomic_count_gcc.hpp>
-
-#elif defined(BOOST_HAS_PTHREADS)
-
-# define BOOST_AC_USE_PTHREADS
-# include <boost/detail/atomic_count_pthreads.hpp>
-
-#else
-
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-#error Unrecognized threading platform
-
-#endif
+#include <boost/smart_ptr/detail/atomic_count.hpp>
#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
typedef T& param_type; // hh removed const
};
-#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x581 ) )
+#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 )
// these are illegal specialisations; cv-qualifies applied to
// references have no effect according to [8.3.2p1],
// C++ Builder requires them though as it treats cv-qualified
-// --------------------------------------------------
+// -----------------------------------------------------------
//
-// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
-// (C) Copyright Gennaro Prota 2003 - 2006.
+// Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+// Copyright (c) 2003-2006, 2008 Gennaro Prota
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//
// -----------------------------------------------------------
-// See http://www.boost.org/libs/dynamic_bitset/ for documentation.
-//
-// $Revision: 41316 $ $Date: 2007-11-23 12:03:14 -0500 (Fri, 23 Nov 2007) $ - $Name$
-
#ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP
#define BOOST_DETAIL_DYNAMIC_BITSET_HPP
-#include <cstddef> // for std::size_t
+#include <cstddef>
#include "boost/config.hpp"
#include "boost/detail/workaround.hpp"
namespace boost {
namespace detail {
+ namespace dynamic_bitset_impl {
// Gives (read-)access to the object representation
// of an object of type T (3.9p4). CANNOT be used
// ------- count function implementation --------------
- namespace dynamic_bitset_count_impl {
-
typedef unsigned char byte_type;
- enum mode { access_by_bytes, access_by_blocks };
+ // These two entities
+ //
+ // enum mode { access_by_bytes, access_by_blocks };
+ // template <mode> struct mode_to_type {};
+ //
+ // were removed, since the regression logs (as of 24 Aug 2008)
+ // showed that several compilers had troubles with recognizing
+ //
+ // const mode m = access_by_bytes
+ //
+ // as a constant expression
+ //
+ // * So, we'll use bool, instead of enum *.
+ //
+ template <bool value>
+ struct value_to_type
+ {
+ value_to_type() {}
+ };
+ const bool access_by_bytes = true;
+ const bool access_by_blocks = false;
- template <mode> struct mode_to_type {};
// the table: wrapped in a class template, so
// that it is only instantiated if/when needed
template <typename Iterator>
inline std::size_t do_count(Iterator first, std::size_t length,
int /*dummy param*/,
-
mode_to_type<access_by_bytes>* )
+
value_to_type<access_by_bytes>* )
{
std::size_t num = 0;
if (length)
//
template <typename Iterator, typename ValueType>
inline std::size_t do_count(Iterator first, std::size_t length, ValueType,
-
mode_to_type<access_by_blocks>*)
+
value_to_type<access_by_blocks>*)
{
std::size_t num = 0;
while (length){
return num;
}
-
- } // dynamic_bitset_count_impl
// -------------------------------------------------------
//
// size_type(-1) / sizeof(T)
//
- // from vector<>::max_size. This tries to get out more
+ // from vector<>::max_size. This tries to get more
// meaningful info.
//
template <typename T>
// for static_asserts
template <typename T>
- struct dynamic_bitset_allowed_block_type {
+ struct allowed_block_type {
enum { value = T(-1) > 0 }; // ensure T has no sign
};
template <>
- struct dynamic_bitset_allowed_block_type<bool> {
+ struct allowed_block_type<bool> {
enum { value = false };
};
+ template <typename T>
+ struct is_numeric {
+ enum { value = false };
+ };
+
+# define BOOST_dynamic_bitset_is_numeric(x) \
+ template<> \
+ struct is_numeric< x > { \
+ enum { value = true }; \
+ } /**/
+
+ BOOST_dynamic_bitset_is_numeric(bool);
+ BOOST_dynamic_bitset_is_numeric(char);
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ BOOST_dynamic_bitset_is_numeric(wchar_t);
+#endif
+
+ BOOST_dynamic_bitset_is_numeric(signed char);
+ BOOST_dynamic_bitset_is_numeric(short int);
+ BOOST_dynamic_bitset_is_numeric(int);
+ BOOST_dynamic_bitset_is_numeric(long int);
+
+ BOOST_dynamic_bitset_is_numeric(unsigned char);
+ BOOST_dynamic_bitset_is_numeric(unsigned short);
+ BOOST_dynamic_bitset_is_numeric(unsigned int);
+ BOOST_dynamic_bitset_is_numeric(unsigned long);
+
+#if defined(BOOST_HAS_LONG_LONG)
+ BOOST_dynamic_bitset_is_numeric(::boost::long_long_type);
+ BOOST_dynamic_bitset_is_numeric(::boost::ulong_long_type);
+#endif
+
+ // intentionally omitted
+ //BOOST_dynamic_bitset_is_numeric(float);
+ //BOOST_dynamic_bitset_is_numeric(double);
+ //BOOST_dynamic_bitset_is_numeric(long double);
+
+#undef BOOST_dynamic_bitset_is_numeric
+
+ } // dynamic_bitset_impl
} // namespace detail
} // namespace boost
# error Unknown machine endianness detected.
# endif
# define BOOST_BYTE_ORDER __BYTE_ORDER
-#elif defined(_BIG_ENDIAN)
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
# define BOOST_BIG_ENDIAN
# define BOOST_BYTE_ORDER 4321
-#elif defined(_LITTLE_ENDIAN)
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
# define BOOST_LITTLE_ENDIAN
# define BOOST_BYTE_ORDER 1234
#elif defined(__sparc) || defined(__sparc__) \
|| defined(_M_ALPHA) || defined(__amd64) \
|| defined(__amd64__) || defined(_M_AMD64) \
|| defined(__x86_64) || defined(__x86_64__) \
- || defined(_M_X64)
+ || defined(_M_X64) || defined(__bfin__)
# define BOOST_LITTLE_ENDIAN
# define BOOST_BYTE_ORDER 1234
//
// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
-// typedef <unspecified> boost::detail::lightweight_mutex;
-//
-// boost::detail::lightweight_mutex is a header-only implementation of
-// a subset of the Mutex concept requirements:
-//
-// http://www.boost.org/doc/html/threads/concepts.html#threads.concepts.Mutex
-//
-// It maps to a CRITICAL_SECTION on Windows or a pthread_mutex on POSIX.
-//
-
-#include <boost/config.hpp>
-#if !defined(BOOST_HAS_THREADS)
-# include <boost/detail/lwm_nop.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
-# include <boost/detail/lwm_pthreads.hpp>
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-# include <boost/detail/lwm_win32_cs.hpp>
-#else
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-# error Unrecognized threading platform
-#endif
+#include <boost/smart_ptr/detail/lightweight_mutex.hpp>
#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
//
// boost/detail/lightweight_test.hpp - lightweight test library
//
-// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2002, 2009 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// BOOST_TEST(expression)
// BOOST_ERROR(message)
+// BOOST_TEST_EQ(expr1, expr2)
//
// int boost::report_errors()
//
++test_errors();
}
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2, char const * file, int line, char const * function, T const & t, U const & u )
+{
+ if( t == u )
+ {
+ }
+ else
+ {
+ std::cerr << file << "(" << line << "): test '" << expr1 << " == " << expr2
+ << "' failed in function '" << function << "': "
+ << "'" << t << "' != '" << u << "'" << std::endl;
+ ++test_errors();
+ }
+}
+
} // namespace detail
inline int report_errors()
{
int errors = detail::test_errors();
- if(errors == 0)
+ if( errors == 0 )
{
std::cerr << "No errors detected." << std::endl;
return 0;
#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
#define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
+#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
// Copyright (c) 2003 David Abrahams
// Copyright (c) 2003 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
-#include <boost/config.hpp>
-
-#include <boost/detail/lightweight_mutex.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-#include <new> // ::operator new, ::operator delete
-#include <cstddef> // std::size_t
-
-namespace boost
-{
-
-namespace detail
-{
-
-template<unsigned size, unsigned align_> union freeblock
-{
- typedef typename boost::type_with_alignment<align_>::type aligner_type;
- aligner_type aligner;
- char bytes[size];
- freeblock * next;
-};
-
-template<unsigned size, unsigned align_> struct allocator_impl
-{
- typedef freeblock<size, align_> block;
-
- // It may seem odd to use such small pages.
- //
- // However, on a typical Windows implementation that uses
- // the OS allocator, "normal size" pages interact with the
- // "ordinary" operator new, slowing it down dramatically.
- //
- // 512 byte pages are handled by the small object allocator,
- // and don't interfere with ::new.
- //
- // The other alternative is to use much bigger pages (1M.)
- //
- // It is surprisingly easy to hit pathological behavior by
- // varying the page size. g++ 2.96 on Red Hat Linux 7.2,
- // for example, passionately dislikes 496. 512 seems OK.
-
-#if defined(BOOST_QA_PAGE_SIZE)
-
- enum { items_per_page = BOOST_QA_PAGE_SIZE / size };
-
-#else
-
- enum { items_per_page = 512 / size }; // 1048560 / size
-
-#endif
-
-#ifdef BOOST_HAS_THREADS
-
- static lightweight_mutex & mutex()
- {
- static lightweight_mutex m;
- return m;
- }
-
- static lightweight_mutex * mutex_init;
-
-#endif
-
- static block * free;
- static block * page;
- static unsigned last;
-
- static inline void * alloc()
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- if(block * x = free)
- {
- free = x->next;
- return x;
- }
- else
- {
- if(last == items_per_page)
- {
- // "Listen to me carefully: there is no memory leak"
- // -- Scott Meyers, Eff C++ 2nd Ed Item 10
- page = ::new block[items_per_page];
- last = 0;
- }
-
- return &page[last++];
- }
- }
-
- static inline void * alloc(std::size_t n)
- {
- if(n != size) // class-specific new called for a derived object
- {
- return ::operator new(n);
- }
- else
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- if(block * x = free)
- {
- free = x->next;
- return x;
- }
- else
- {
- if(last == items_per_page)
- {
- page = ::new block[items_per_page];
- last = 0;
- }
-
- return &page[last++];
- }
- }
- }
-
- static inline void dealloc(void * pv)
- {
- if(pv != 0) // 18.4.1.1/13
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- block * pb = static_cast<block *>(pv);
- pb->next = free;
- free = pb;
- }
- }
-
- static inline void dealloc(void * pv, std::size_t n)
- {
- if(n != size) // class-specific delete called for a derived object
- {
- ::operator delete(pv);
- }
- else if(pv != 0) // 18.4.1.1/13
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- block * pb = static_cast<block *>(pv);
- pb->next = free;
- free = pb;
- }
- }
-};
-
-#ifdef BOOST_HAS_THREADS
-
-template<unsigned size, unsigned align_>
- lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex();
-
-#endif
-
-template<unsigned size, unsigned align_>
- freeblock<size, align_> * allocator_impl<size, align_>::free = 0;
-
-template<unsigned size, unsigned align_>
- freeblock<size, align_> * allocator_impl<size, align_>::page = 0;
-
-template<unsigned size, unsigned align_>
- unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page;
-
-template<class T>
-struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
+#include <boost/smart_ptr/detail/quick_allocator.hpp>
#endif // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
-// Copyright © 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
// Distributed under the Boost Software License, Version 1.0. (See accompany-
// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#else
#define __BORLANDC___WORKAROUND_GUARD 0
#endif
-#ifndef __MSC_VER
-#define __MSC_VER_WORKAROUND_GUARD 1
+#ifndef __CODEGEARC__
+#define __CODEGEARC___WORKAROUND_GUARD 1
#else
-#define __MSC_VER_WORKAROUND_GUARD 0
+#define __CODEGEARC___WORKAROUND_GUARD 0
+#endif
+#ifndef _MSC_VER
+#define _MSC_VER_WORKAROUND_GUARD 1
+#else
+#define _MSC_VER_WORKAROUND_GUARD 0
#endif
#ifndef _MSC_FULL_VER
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#else
#define __MWERKS___WORKAROUND_GUARD 0
#endif
+#ifndef __EDG__
+#define __EDG___WORKAROUND_GUARD 1
+#else
+#define __EDG___WORKAROUND_GUARD 0
+#endif
#ifndef __EDG_VERSION__
#define __EDG_VERSION___WORKAROUND_GUARD 1
#else
#else
#define __HP_aCC_WORKAROUND_GUARD 0
#endif
+#ifndef __hpxstd98
+#define __hpxstd98_WORKAROUND_GUARD 1
+#else
+#define __hpxstd98_WORKAROUND_GUARD 0
+#endif
#ifndef _CRAYC
#define _CRAYC_WORKAROUND_GUARD 1
#else
#else
#define MPW_CPLUS_WORKAROUND_GUARD 0
#endif
+#ifndef __COMO__
+#define __COMO___WORKAROUND_GUARD 1
+#else
+#define __COMO___WORKAROUND_GUARD 0
+#endif
+#ifndef __COMO_VERSION__
+#define __COMO_VERSION___WORKAROUND_GUARD 1
+#else
+#define __COMO_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef __INTEL_COMPILER
+#define __INTEL_COMPILER_WORKAROUND_GUARD 1
+#else
+#define __INTEL_COMPILER_WORKAROUND_GUARD 0
+#endif
+#ifndef __ICL
+#define __ICL_WORKAROUND_GUARD 1
+#else
+#define __ICL_WORKAROUND_GUARD 0
+#endif
+#ifndef _COMPILER_VERSION
+#define _COMPILER_VERSION_WORKAROUND_GUARD 1
+#else
+#define _COMPILER_VERSION_WORKAROUND_GUARD 0
+#endif
#ifndef _RWSTD_VER
#define _RWSTD_VER_WORKAROUND_GUARD 1
#else
#define _RWSTD_VER_WORKAROUND_GUARD 0
#endif
+#ifndef BOOST_RWSTD_VER
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __GLIBCPP__
+#define __GLIBCPP___WORKAROUND_GUARD 1
+#else
+#define __GLIBCPP___WORKAROUND_GUARD 0
+#endif
#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#else
#else
#define _STLPORT_VERSION_WORKAROUND_GUARD 0
#endif
+#ifndef __LIBCOMO_VERSION__
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
+#else
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef _CPPLIB_VER
+#define _CPPLIB_VER_WORKAROUND_GUARD 1
+#else
+#define _CPPLIB_VER_WORKAROUND_GUARD 0
+#endif
#ifndef BOOST_INTEL_CXX_VERSION
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
//
// Copyright (c) 2002 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
//
-#include <boost/weak_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-namespace boost
-{
-
-template<class T> class enable_shared_from_this
-{
-protected:
-
- enable_shared_from_this()
- {
- }
-
- enable_shared_from_this(enable_shared_from_this const &)
- {
- }
-
- enable_shared_from_this & operator=(enable_shared_from_this const &)
- {
- return *this;
- }
-
- ~enable_shared_from_this()
- {
- }
-
-public:
-
- shared_ptr<T> shared_from_this()
- {
- shared_ptr<T> p(_internal_weak_this);
- BOOST_ASSERT(p.get() == this);
- return p;
- }
-
- shared_ptr<T const> shared_from_this() const
- {
- shared_ptr<T const> p(_internal_weak_this);
- BOOST_ASSERT(p.get() == this);
- return p;
- }
-
-// Note: No, you don't need to initialize _internal_weak_this
-//
-// Please read the documentation, not the code
-//
-// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
-
- typedef T _internal_element_type; // for bcc 5.5.1
- mutable weak_ptr<_internal_element_type> _internal_weak_this;
-};
-
-} // namespace boost
+#include <boost/smart_ptr/enable_shared_from_this.hpp>
#endif // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef UUID_6F463AC838DF11DDA3E6909F56D89593
#define UUID_6F463AC838DF11DDA3E6909F56D89593
+#include <boost/exception/detail/type_info.hpp>
#include <iomanip>
-#include <typeinfo>
#include <ios>
#include <string>
#include <sstream>
object_hex_dump( T const & x, size_t max_size=16 )
{
std::ostringstream s;
- s << "type: " << typeid(x).name() << ", size: " << sizeof(T) << ", dump: ";
+ s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
size_t n=sizeof(T)>max_size?max_size:sizeof(T);
s.fill('0');
s.width(2);
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef UUID_0552D49838DD11DD90146B8956D89593
#define UUID_0552D49838DD11DD90146B8956D89593
-#include <boost/exception/exception.hpp>
+#include <boost/config.hpp>
+#include <boost/exception/get_error_info.hpp>
+#include <boost/utility/enable_if.hpp>
#include <exception>
+#include <sstream>
#include <string>
+namespace
+boost
+ {
+ namespace
+ exception_detail
+ {
+ template <class T>
+ struct
+ enable_boost_exception_overload
+ {
+ struct yes { char q[100]; };
+ typedef char no;
+ static yes check(exception const *);
+ static no check(...);
+ enum e { value=sizeof(check((T*)0))==sizeof(yes) };
+ };
+
+ template <class T>
+ struct
+ enable_std_exception_overload
+ {
+ struct yes { char q[100]; };
+ typedef char no;
+ static yes check(std::exception const *);
+ static no check(...);
+ enum e { value = !enable_boost_exception_overload<T>::value && sizeof(check((T*)0))==sizeof(yes) };
+ };
+
+#ifndef BOOST_NO_RTTI
+ template <class T>
+ inline
+ std::string
+ dynamic_exception_type( T const & x )
+ {
+ return std::string("Dynamic exception type: ") + BOOST_EXCEPTION_DYNAMIC_TYPEID(x).name();
+ }
+#endif
+
+ inline
+ char const *
+ get_diagnostic_information( exception const & x )
+ {
+ if( error_info_container * c=x.data_.get() )
+#ifndef BOOST_NO_EXCEPTIONS
+ try
+ {
+#endif
+ return c->diagnostic_information();
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ }
+#endif
+ return 0;
+ }
+
+ inline
+ std::string
+ boost_diagnostic_information( exception const & x )
+ {
+ std::ostringstream tmp;
+ if( char const * const * f=get_error_info<throw_file>(x) )
+ {
+ tmp << *f;
+ if( int const * l=get_error_info<throw_line>(x) )
+ tmp << '(' << *l << "): ";
+ }
+ tmp << "Throw in function ";
+ if( char const * const * fn=get_error_info<throw_function>(x) )
+ tmp << *fn;
+ else
+ tmp << "(unknown)";
+ tmp << std::endl;
+#ifndef BOOST_NO_RTTI
+ tmp << dynamic_exception_type(x) << std::endl;
+ if( std::exception const * e=dynamic_cast<std::exception const *>(&x) )
+ tmp << "std::exception::what: " << e->what() << std::endl;
+#endif
+ if( char const * s=exception_detail::get_diagnostic_information(x) )
+ if( *s )
+ tmp << s;
+ return tmp.str();
+ }
+
+ inline
+ std::string
+ std_diagnostic_information( std::exception const & x )
+ {
+ std::ostringstream tmp;
+#ifndef BOOST_NO_RTTI
+ if( exception const * e=dynamic_cast<exception const *>(&x) )
+ return boost_diagnostic_information(*e);
+ tmp << dynamic_exception_type(x) << std::endl;
+#endif
+ tmp << "std::exception::what: " << x.what() << std::endl;
+ return tmp.str();
+ }
+ }
+
+ template <class T>
+ inline
+ typename enable_if<exception_detail::enable_boost_exception_overload<T>,std::string>::type
+ diagnostic_information( T const & e )
+ {
+ return exception_detail::boost_diagnostic_information(e);
+ }
+
+ template <class T>
+ inline
+ typename enable_if<exception_detail::enable_std_exception_overload<T>,std::string>::type
+ diagnostic_information( T const & e )
+ {
+ return exception_detail::std_diagnostic_information(e);
+ }
+ }
+
+#ifndef BOOST_NO_EXCEPTIONS
+#include <boost/exception/current_exception_cast.hpp>
namespace
boost
{
inline
std::string
- diagnostic_information( std::exception const & x )
+ current_exception_diagnostic_information()
{
- if( exception const * be = dynamic_cast<exception const *>(&x) )
- return be->diagnostic_information();
+ if( boost::exception const * e=current_exception_cast<boost::exception const>() )
+ return diagnostic_information(*e);
+ else if( std::exception const * e=current_exception_cast<std::exception const>() )
+ return diagnostic_information(*e);
else
- return std::string("[ what: ") + x.what() + ", type: " + typeid(x).name() + " ]";
+ return "No diagnostic information available.";
}
- }
+ }
+#endif
#endif
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef UUID_78CC85B2914F11DC8F47B48E55D89593
-#define UUID_78CC85B2914F11DC8F47B48E55D89593
-
#include <boost/exception/exception.hpp>
-#include <boost/exception/detail/cloning_base.hpp>
-#include <boost/detail/atomic_count.hpp>
-#include <boost/assert.hpp>
-#include <new>
-
-namespace
-boost
- {
- namespace
- exception_detail
- {
- class
- clone_base:
- public counted_base
- {
- public:
-
- virtual void rethrow() const=0;
- };
-
- struct
- bad_alloc_impl:
- public clone_base,
- public std::bad_alloc
- {
- void
- add_ref() const
- {
- }
-
- void
- release() const
- {
- }
-
- void
- rethrow() const
- {
- throw *this;
- }
- };
-
- template <class T>
- clone_base * make_clone( T const & );
-
- template <class T>
- class
- clone_impl:
- public T,
- public cloning_base
- {
- public:
-
- explicit
- clone_impl( T const & x ):
- T(x)
- {
- if( boost::exception * be1=dynamic_cast<boost::exception *>(this) )
- if( boost::exception const * be2=dynamic_cast<boost::exception const *>(&x) )
- *be1 = *be2;
- }
-
- private:
-
- clone_base const *
- clone() const
- {
- return make_clone<T>(*this);
- }
- };
-
- template <class T>
- class
- exception_clone:
- public T,
- public clone_base
- {
- public:
-
- explicit
- exception_clone( T const & x ):
- T(x),
- count_(0)
- {
- if( boost::exception * be1=dynamic_cast<boost::exception *>(this) )
- if( boost::exception const * be2=dynamic_cast<boost::exception const *>(&x) )
- *be1 = *be2;
- }
-
- private:
-
- detail::atomic_count mutable count_;
-
- void
- add_ref() const
- {
- ++count_;
- }
-
- void
- release() const
- {
- if( !--count_ )
- delete this;
- }
-
- void
- rethrow() const
- {
- throw clone_impl<T>(*this);
- }
- };
-
- template <class T>
- inline
- clone_base *
- make_clone( T const & x )
- {
- try
- {
- return new exception_clone<T>(x);
- }
- catch(
- std::bad_alloc & )
- {
- static bad_alloc_impl bad_alloc;
- return &bad_alloc;
- }
- catch(
- ... )
- {
- BOOST_ASSERT(0);
- return 0;
- }
- }
- }
-
- template <class T>
- inline
- exception_detail::clone_impl<T>
- enable_current_exception( T const & x )
- {
- return exception_detail::clone_impl<T>(x);
- }
- }
-
-#endif
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef UUID_0C5D492E909711DCB658AD4556D89593
-#define UUID_0C5D492E909711DCB658AD4556D89593
-
#include <boost/exception/exception.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/config.hpp>
-#include <stddef.h>
-
-namespace
-boost
- {
- namespace
- exception_detail
- {
- template <class T>
- struct
- error_info_injector:
- public T,
- public exception
- {
- explicit
- error_info_injector( T const & x ):
- T(x)
- {
- }
-
- ~error_info_injector() throw()
- {
- }
-
- char const *
- diagnostic_information() const throw()
- {
- return boost::exception::_diagnostic_information(T::what());
- }
- };
-
- struct large_size { char c[256]; };
- large_size dispatch( exception * );
-
- struct small_size { };
- small_size dispatch( void * );
-
- template <class,size_t>
- struct enable_error_info_helper;
-
- template <class T>
- struct
- enable_error_info_helper<T,sizeof(large_size)>
- {
- typedef T type;
- };
-
- template <class T>
- struct
- enable_error_info_helper<T,sizeof(small_size)>
- {
- typedef error_info_injector<T> type;
- };
-
-#if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x582))
- template <class T>
- struct
- sizeof_dispatch
- {
- BOOST_STATIC_CONSTANT(int, value = sizeof(dispatch((T*)0)) );
- };
-
- template <class T>
- struct
- enable_error_info_return_type
- {
- typedef typename enable_error_info_helper<T,sizeof_dispatch<T>::value>::type type;
- };
-#else
- template <class T>
- struct
- enable_error_info_return_type
- {
- typedef typename enable_error_info_helper<T,sizeof(dispatch((T*)0))>::type type;
- };
-#endif
- }
-
- template <class T>
- inline
-#if !BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x582))
- typename
-#endif
- exception_detail::enable_error_info_return_type<T>::type
- enable_error_info( T const & x )
- {
- return
-#if !BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x582))
- typename
-#endif
- exception_detail::enable_error_info_return_type<T>::type(x);
- }
- }
-
-#endif
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef UUID_0E57632CCA3011DCB876FD9955D89593
-#define UUID_0E57632CCA3011DCB876FD9955D89593
-
-namespace
-boost
- {
- template <class Tag,class T>
- class error_info;
- }
-
-#endif
+namespace boost { template <class Tag,class T> class error_info; }
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef UUID_274DA366004E11DCB1DDFE2E56D89593
#define UUID_274DA366004E11DCB1DDFE2E56D89593
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/exception/detail/counted_base.hpp>
-#include <boost/intrusive_ptr.hpp>
-#include <typeinfo>
-
namespace
boost
{
- template <class T>
- class shared_ptr;
-
namespace
exception_detail
{
- class error_info_base;
-
- struct
- error_info_container:
- public exception_detail::counted_base
+ template <class T>
+ class
+ refcount_ptr
{
- virtual char const * diagnostic_information( char const *, std::type_info const & ) const = 0;
- virtual shared_ptr<error_info_base const> get( std::type_info const & ) const = 0;
- virtual void set( shared_ptr<error_info_base const> const & ) = 0;
+ public:
+
+ refcount_ptr():
+ px_(0)
+ {
+ }
+
+ ~refcount_ptr()
+ {
+ release();
+ }
+
+ refcount_ptr( refcount_ptr const & x ):
+ px_(x.px_)
+ {
+ add_ref();
+ }
+
+ refcount_ptr &
+ operator=( refcount_ptr const & x )
+ {
+ adopt(x.px_);
+ return *this;
+ }
+
+ void
+ adopt( T * px )
+ {
+ release();
+ px_=px;
+ add_ref();
+ }
+
+ T *
+ get() const
+ {
+ return px_;
+ }
+
+ private:
+
+ T * px_;
+
+ void
+ add_ref()
+ {
+ if( px_ )
+ px_->add_ref();
+ }
+
+ void
+ release()
+ {
+ if( px_ )
+ px_->release();
+ }
};
}
+ ////////////////////////////////////////////////////////////////////////
+
template <class Tag,class T>
class error_info;
- template <class E,class Tag,class T>
- E const & operator<<( E const &, error_info<Tag,T> const & );
+ typedef error_info<struct tag_throw_function,char const *> throw_function;
+ typedef error_info<struct tag_throw_file,char const *> throw_file;
+ typedef error_info<struct tag_throw_line,int> throw_line;
- template <class ErrorInfo,class E>
- shared_ptr<typename ErrorInfo::value_type const> get_error_info( E const & );
+ template <>
+ class
+ error_info<tag_throw_function,char const *>
+ {
+ public:
+ typedef char const * value_type;
+ value_type v_;
+ explicit
+ error_info( value_type v ):
+ v_(v)
+ {
+ }
+ };
+ template <>
class
- exception
+ error_info<tag_throw_file,char const *>
{
public:
+ typedef char const * value_type;
+ value_type v_;
+ explicit
+ error_info( value_type v ):
+ v_(v)
+ {
+ }
+ };
- virtual
- char const *
- diagnostic_information() const throw()
+ template <>
+ class
+ error_info<tag_throw_line,int>
+ {
+ public:
+ typedef int value_type;
+ value_type v_;
+ explicit
+ error_info( value_type v ):
+ v_(v)
{
- return _diagnostic_information(0);
}
+ };
+
+ template <class E,class Tag,class T>
+ E const & operator<<( E const &, error_info<Tag,T> const & );
+
+ class exception;
+ template <class>
+ class shared_ptr;
+
+ namespace
+ exception_detail
+ {
+ class error_info_base;
+ struct type_info_;
+
+ struct
+ error_info_container
+ {
+ virtual char const * diagnostic_information() const = 0;
+ virtual shared_ptr<error_info_base const> get( type_info_ const & ) const = 0;
+ virtual void set( shared_ptr<error_info_base const> const &, type_info_ const & ) = 0;
+ virtual void add_ref() const = 0;
+ virtual void release() const = 0;
+
+ protected:
+
+ virtual
+ ~error_info_container() throw()
+ {
+ }
+ };
+
+ template <class>
+ struct get_info;
+
+ template <>
+ struct get_info<throw_function>;
+
+ template <>
+ struct get_info<throw_file>;
+
+ template <>
+ struct get_info<throw_line>;
+
+ char const * get_diagnostic_information( exception const & );
+ }
+
+ class
+ exception
+ {
protected:
- exception()
+ exception():
+ throw_function_(0),
+ throw_file_(0),
+ throw_line_(-1)
{
}
- exception( exception const & e ):
- data_(e.data_)
+#ifdef __HP_aCC
+ //On HP aCC, this protected copy constructor prevents throwing boost::exception.
+ //On all other platforms, the same effect is achieved by the pure virtual destructor.
+ exception( exception const & x ) throw():
+ data_(x.data_),
+ throw_function_(x.throw_function_),
+ throw_file_(x.throw_file_),
+ throw_line_(x.throw_line_)
{
}
+#endif
+
+ virtual ~exception() throw()
+#ifndef __HP_aCC
+ = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors.
+#endif
+ ;
+
+ private:
- char const *
- _diagnostic_information( char const * std_what ) const throw()
- {
- if( data_ )
- try
- {
- char const * w = data_->diagnostic_information(std_what,typeid(*this));
- BOOST_ASSERT(0!=w);
- return w;
- }
- catch(...)
- {
- }
- return std_what ? std_what : typeid(*this).name();
+ template <class E>
+ friend
+ E const &
+ operator<<( E const & x, throw_function const & y )
+ {
+ x.throw_function_=y.v_;
+ return x;
}
-#if BOOST_WORKAROUND( BOOST_MSVC, BOOST_TESTED_AT(1500) )
- //Force class exception to be abstract.
- //Otherwise, MSVC bug allows throw exception(), even though the copy constructor is protected.
- virtual ~exception() throw()=0;
-#else
-#if BOOST_WORKAROUND( __GNUC__, BOOST_TESTED_AT(4) )
- virtual //Disable bogus GCC warning.
-#endif
- ~exception() throw()
+ template <class E>
+ friend
+ E const &
+ operator<<( E const & x, throw_file const & y )
{
+ x.throw_file_=y.v_;
+ return x;
}
-#endif
- private:
+ template <class E>
+ friend
+ E const &
+ operator<<( E const & x, throw_line const & y )
+ {
+ x.throw_line_=y.v_;
+ return x;
+ }
- shared_ptr<exception_detail::error_info_base const> get( std::type_info const & ) const;
- void set( shared_ptr<exception_detail::error_info_base const> const & ) const;
+ friend char const * exception_detail::get_diagnostic_information( exception const & );
template <class E,class Tag,class T>
friend E const & operator<<( E const &, error_info<Tag,T> const & );
- template <class ErrorInfo,class E>
- friend shared_ptr<typename ErrorInfo::value_type const> get_error_info( E const & );
+ template <class>
+ friend struct exception_detail::get_info;
+ friend struct exception_detail::get_info<throw_function>;
+ friend struct exception_detail::get_info<throw_file>;
+ friend struct exception_detail::get_info<throw_line>;
- intrusive_ptr<exception_detail::error_info_container> mutable data_;
+ mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
+ mutable char const * throw_function_;
+ mutable char const * throw_file_;
+ mutable int throw_line_;
};
-#if BOOST_WORKAROUND( BOOST_MSVC, BOOST_TESTED_AT(1500) ) //See above.
inline
exception::
~exception() throw()
{
}
-#endif
+
+ ////////////////////////////////////////////////////////////////////////
+
+ namespace
+ exception_detail
+ {
+ template <class T>
+ struct
+ error_info_injector:
+ public T,
+ public exception
+ {
+ explicit
+ error_info_injector( T const & x ):
+ T(x)
+ {
+ }
+
+ ~error_info_injector() throw()
+ {
+ }
+ };
+
+ struct large_size { char c[256]; };
+ large_size dispatch( exception * );
+
+ struct small_size { };
+ small_size dispatch( void * );
+
+ template <class,int>
+ struct enable_error_info_helper;
+
+ template <class T>
+ struct
+ enable_error_info_helper<T,sizeof(large_size)>
+ {
+ typedef T type;
+ };
+
+ template <class T>
+ struct
+ enable_error_info_helper<T,sizeof(small_size)>
+ {
+ typedef error_info_injector<T> type;
+ };
+
+ template <class T>
+ struct
+ enable_error_info_return_type
+ {
+ typedef typename enable_error_info_helper<T,sizeof(dispatch((T*)0))>::type type;
+ };
+ }
+
+ template <class T>
+ inline
+ typename
+ exception_detail::enable_error_info_return_type<T>::type
+ enable_error_info( T const & x )
+ {
+ typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
+ return rt(x);
+ }
+
+ ////////////////////////////////////////////////////////////////////////
+
+ namespace
+ exception_detail
+ {
+ class
+ clone_base
+ {
+ public:
+
+ virtual clone_base const * clone() const = 0;
+ virtual void rethrow() const = 0;
+
+ virtual
+ ~clone_base() throw()
+ {
+ }
+ };
+
+ inline
+ void
+ copy_boost_exception( exception * a, exception const * b )
+ {
+ *a = *b;
+ }
+
+ inline
+ void
+ copy_boost_exception( void *, void const * )
+ {
+ }
+
+ template <class T>
+ class
+ clone_impl:
+ public T,
+ public clone_base
+ {
+ public:
+
+ explicit
+ clone_impl( T const & x ):
+ T(x)
+ {
+ copy_boost_exception(this,&x);
+ }
+
+ ~clone_impl() throw()
+ {
+ }
+
+ private:
+
+ clone_base const *
+ clone() const
+ {
+ return new clone_impl(*this);
+ }
+
+ void
+ rethrow() const
+ {
+ throw*this;
+ }
+ };
+ }
+
+ template <class T>
+ inline
+ exception_detail::clone_impl<T>
+ enable_current_exception( T const & x )
+ {
+ return exception_detail::clone_impl<T>(x);
+ }
}
#endif
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef UUID_8D22C4CA9CC811DCAA9133D256D89593
#define UUID_8D22C4CA9CC811DCAA9133D256D89593
-#include <boost/type.hpp>
#include <boost/exception/exception.hpp>
-#include <boost/exception/error_info.hpp>
#include <boost/exception/to_string_stub.hpp>
-#include <boost/current_function.hpp>
+#include <boost/exception/detail/error_info_impl.hpp>
#include <boost/shared_ptr.hpp>
#include <map>
-#define BOOST_ERROR_INFO\
- ::boost::throw_function(BOOST_CURRENT_FUNCTION) <<\
- ::boost::throw_file(__FILE__) <<\
- ::boost::throw_line((int)__LINE__)
-
namespace
boost
{
- typedef error_info<struct tag_throw_function,char const *> throw_function;
- typedef error_info<struct tag_throw_file,char const *> throw_file;
- typedef error_info<struct tag_throw_line,int> throw_line;
-
- namespace
- exception_detail
+ template <class Tag,class T>
+ inline
+ typename enable_if<has_to_string<T>,std::string>::type
+ to_string( error_info<Tag,T> const & x )
{
- class
- error_info_base
- {
- public:
-
- virtual std::type_info const & tag_typeid() const = 0;
- virtual std::string value_as_string() const = 0;
-
- protected:
-
-#if BOOST_WORKAROUND( __GNUC__, BOOST_TESTED_AT(4) )
-virtual //Disable bogus GCC warning.
-#endif
- ~error_info_base()
- {
- }
- };
+ return to_string(x.value());
}
template <class Tag,class T>
- class
- error_info:
- public exception_detail::error_info_base
+ inline
+ error_info<Tag,T>::
+ error_info( value_type const & value ):
+ value_(value)
{
- public:
-
- typedef T value_type;
-
- error_info( value_type const & value ):
- value_(value)
- {
- }
-
- value_type const &
- value() const
- {
- return value_;
- }
-
- private:
-
- std::type_info const &
- tag_typeid() const
- {
- return typeid(type<Tag>);
- }
-
- std::string
- value_as_string() const
- {
- return to_string_stub(value_);
- }
+ }
- value_type const value_;
- };
+ template <class Tag,class T>
+ inline
+ error_info<Tag,T>::
+ ~error_info() throw()
+ {
+ }
- template <class E,class Tag,class T>
+ template <class Tag,class T>
inline
- E const &
- operator<<( E const & x, error_info<Tag,T> const & v )
+ char const *
+ error_info<Tag,T>::
+ tag_typeid_name() const
{
- shared_ptr< error_info<Tag,T> > p( new error_info<Tag,T>(v) );
- x.set(p);
- return x;
+ return tag_type_name<Tag>();
}
- template <class ErrorInfo,class E>
+ template <class Tag,class T>
inline
- shared_ptr<typename ErrorInfo::value_type const>
- get_error_info( E const & some_exception )
+ std::string
+ error_info<Tag,T>::
+ value_as_string() const
{
- if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
- if( shared_ptr<exception_detail::error_info_base const> eib = x->get(typeid(ErrorInfo)) )
- {
- BOOST_ASSERT( 0!=dynamic_cast<ErrorInfo const *>(eib.get()) );
- ErrorInfo const * w = static_cast<ErrorInfo const *>(eib.get());
- return shared_ptr<typename ErrorInfo::value_type const>(eib,&w->value());
- }
- return shared_ptr<typename ErrorInfo::value_type const>();
+ return to_string_stub(*this);
}
namespace
{
}
+ void
+ set( shared_ptr<error_info_base const> const & x, type_info_ const & typeid_ )
+ {
+ BOOST_ASSERT(x);
+ info_[typeid_] = x;
+ diagnostic_info_str_.clear();
+ }
+
shared_ptr<error_info_base const>
- get( std::type_info const & ti ) const
+ get( type_info_ const & ti ) const
{
- error_info_map::const_iterator i=info_.find(typeinfo(ti));
+ error_info_map::const_iterator i=info_.find(ti);
if( info_.end()!=i )
{
shared_ptr<error_info_base const> const & p = i->second;
- BOOST_ASSERT( typeid(*p)==ti );
+#ifndef BOOST_NO_RTTI
+ BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p)==ti );
+#endif
return p;
}
return shared_ptr<error_info_base const>();
}
- void
- set( shared_ptr<error_info_base const> const & x )
- {
- BOOST_ASSERT(x);
- info_[typeinfo(typeid(*x))] = x;
- what_.clear();
- }
-
char const *
- diagnostic_information( char const * std_what, std::type_info const & exception_type ) const
+ diagnostic_information() const
{
- if( what_.empty() )
+ if( diagnostic_info_str_.empty() )
{
- std::string tmp;
- if( std_what )
- {
- tmp += std_what;
- tmp += '\n';
- }
- tmp += "Dynamic exception type: ";
- tmp += exception_type.name();
- tmp += '\n';
+ std::ostringstream tmp;
for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
{
shared_ptr<error_info_base const> const & x = i->second;
- tmp += '[';
- tmp += x->tag_typeid().name();
- tmp += "] = ";
- tmp += x->value_as_string();
- tmp += '\n';
+ tmp << '[' << x->tag_typeid_name() << "] = " << x->value_as_string() << std::endl;
}
- what_.swap(tmp);
+ tmp.str().swap(diagnostic_info_str_);
}
- return what_.c_str();
+ return diagnostic_info_str_.c_str();
}
private:
- friend class exception;
-
- struct
- typeinfo
- {
- std::type_info const * type;
-
- explicit
- typeinfo( std::type_info const & t ):
- type(&t)
- {
- }
-
- bool
- operator<( typeinfo const & b ) const
- {
- return 0!=(type->before(*b.type));
- }
- };
+ friend class boost::exception;
- typedef std::map< typeinfo, shared_ptr<error_info_base const> > error_info_map;
+ typedef std::map< type_info_, shared_ptr<error_info_base const> > error_info_map;
error_info_map info_;
- std::string mutable what_;
- int mutable count_;
+ mutable std::string diagnostic_info_str_;
+ mutable int count_;
void
add_ref() const
};
}
+ template <class E,class Tag,class T>
inline
- void
- exception::
- set( shared_ptr<exception_detail::error_info_base const> const & x ) const
- {
- if( !data_ )
- data_ = intrusive_ptr<exception_detail::error_info_container>(new exception_detail::error_info_container_impl);
- data_->set(x);
- }
-
- inline
- shared_ptr<exception_detail::error_info_base const>
- exception::
- get( std::type_info const & ti ) const
+ E const &
+ operator<<( E const & x, error_info<Tag,T> const & v )
{
- if( data_ )
- return data_->get(ti);
- else
- return shared_ptr<exception_detail::error_info_base const>();
+ typedef error_info<Tag,T> error_info_tag_t;
+ shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
+ exception_detail::error_info_container * c;
+ if( !(c=x.data_.get()) )
+ x.data_.adopt(c=new exception_detail::error_info_container_impl);
+ c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
+ return x;
}
}
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if ! defined( BOOST_NO_LOCALE_ISDIGIT )
return fac.is(std::ctype<Ch>::digit, c);
# else
+ (void) fac; // remove "unused parameter" warning
using namespace std;
return isdigit(c);
#endif
#include <typeinfo>
#include <boost/config.hpp>
#include <boost/assert.hpp>
+#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/composite_traits.hpp>
+#include <boost/type_traits/ice.hpp>
#include <boost/ref.hpp>
#include <boost/mpl/if.hpp>
#include <boost/detail/workaround.hpp>
# include "boost/mpl/bool.hpp"
#endif
#include <boost/function_equal.hpp>
+#include <boost/function/function_fwd.hpp>
#if defined(BOOST_MSVC)
# pragma warning( push )
# define BOOST_FUNCTION_TARGET_FIX(x)
#endif // not MSVC
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// Work around a compiler bug.
-// boost::python::objects::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace objects {
- class function;
-}}}
-#endif
-
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-#endif
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
(::boost::is_integral<Functor>::value)>::value), \
Type>::type
#endif
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-namespace boost {
-
-template<typename Signature>
-class function;
-
-template<typename Signature>
-inline void swap(function<Signature>& f1,
- function<Signature>& f2)
-{
- f1.swap(f2);
-}
-
-} // end namespace boost
-#endif // have partial specialization
-
namespace boost {
namespace detail {
namespace function {
union function_buffer
{
// For pointers to function objects
- void* obj_ptr;
+ mutable void* obj_ptr;
// For pointers to std::type_info objects
- // (get_functor_type_tag, check_functor_type_tag).
- const void* const_obj_ptr;
+ struct type_t {
+ // (get_functor_type_tag, check_functor_type_tag).
+ const BOOST_FUNCTION_STD_NS::type_info* type;
+
+ // Whether the type is const-qualified.
+ bool const_qualified;
+ // Whether the type is volatile-qualified.
+ bool volatile_qualified;
+ } type;
// For function pointers of all kinds
mutable void (*func_ptr)();
void* obj_ptr;
} bound_memfunc_ptr;
+ // For references to function objects. We explicitly keep
+ // track of the cv-qualifiers on the object referenced.
+ struct obj_ref_t {
+ mutable void* obj_ptr;
+ bool is_const_qualified;
+ bool is_volatile_qualified;
+ } obj_ref;
+
// To relax aliasing constraints
mutable char data;
};
// The operation type to perform on the given functor/function pointer
enum functor_manager_operation_type {
clone_functor_tag,
+ move_functor_tag,
destroy_functor_tag,
check_functor_type_tag,
get_functor_type_tag
struct reference_manager
{
static inline void
- get(const function_buffer& in_buffer, function_buffer& out_buffer,
- functor_manager_operation_type op)
+ manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+ functor_manager_operation_type op)
{
switch (op) {
case clone_functor_tag:
- out_buffer.obj_ptr = in_buffer.obj_ptr;
+ out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+ return;
+
+ case move_functor_tag:
+ out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+ in_buffer.obj_ref.obj_ptr = 0;
return;
case destroy_functor_tag:
- out_buffer.obj_ptr = 0;
+ out_buffer.obj_ref.obj_ptr = 0;
return;
case check_functor_type_tag:
{
- // DPG TBD: Since we're only storing a pointer, it's
- // possible that the user could ask for a base class or
- // derived class. Is that okay?
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
- if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
- out_buffer.obj_ptr = in_buffer.obj_ptr;
+ const BOOST_FUNCTION_STD_NS::type_info& check_type
+ = *out_buffer.type.type;
+
+ // Check whether we have the same type. We can add
+ // cv-qualifiers, but we can't take them away.
+ if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
+ && (!in_buffer.obj_ref.is_const_qualified
+ || out_buffer.type.const_qualified)
+ && (!in_buffer.obj_ref.is_volatile_qualified
+ || out_buffer.type.volatile_qualified))
+ out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
else
out_buffer.obj_ptr = 0;
}
return;
case get_functor_type_tag:
- out_buffer.const_obj_ptr = &typeid(F);
+ out_buffer.type.type = &typeid(F);
+ out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
+ out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
return;
}
}
{
if (op == clone_functor_tag)
out_buffer.func_ptr = in_buffer.func_ptr;
- else if (op == destroy_functor_tag)
+ else if (op == move_functor_tag) {
+ out_buffer.func_ptr = in_buffer.func_ptr;
+ in_buffer.func_ptr = 0;
+ } else if (op == destroy_functor_tag)
out_buffer.func_ptr = 0;
- else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ else if (op == check_functor_type_tag) {
+ const BOOST_FUNCTION_STD_NS::type_info& check_type
+ = *out_buffer.type.type;
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = &in_buffer.func_ptr;
else
out_buffer.obj_ptr = 0;
+ } else /* op == get_functor_type_tag */ {
+ out_buffer.type.type = &typeid(Functor);
+ out_buffer.type.const_qualified = false;
+ out_buffer.type.volatile_qualified = false;
}
}
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
{
- if (op == clone_functor_tag) {
+ if (op == clone_functor_tag || op == move_functor_tag) {
const functor_type* in_functor =
reinterpret_cast<const functor_type*>(&in_buffer.data);
new ((void*)&out_buffer.data) functor_type(*in_functor);
+
+ if (op == move_functor_tag) {
+ reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+ }
} else if (op == destroy_functor_tag) {
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
- } else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ } else if (op == check_functor_type_tag) {
+ const BOOST_FUNCTION_STD_NS::type_info& check_type
+ = *out_buffer.type.type;
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = &in_buffer.data;
else
out_buffer.obj_ptr = 0;
+ } else /* op == get_functor_type_tag */ {
+ out_buffer.type.type = &typeid(Functor);
+ out_buffer.type.const_qualified = false;
+ out_buffer.type.volatile_qualified = false;
}
}
};
(const functor_type*)(in_buffer.obj_ptr);
functor_type* new_f = new functor_type(*f);
out_buffer.obj_ptr = new_f;
+ } else if (op == move_functor_tag) {
+ out_buffer.obj_ptr = in_buffer.obj_ptr;
+ in_buffer.obj_ptr = 0;
} else if (op == destroy_functor_tag) {
/* Cast from the void pointer to the functor pointer type */
functor_type* f =
static_cast<functor_type*>(out_buffer.obj_ptr);
delete f;
out_buffer.obj_ptr = 0;
- } else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ } else if (op == check_functor_type_tag) {
+ const BOOST_FUNCTION_STD_NS::type_info& check_type
+ = *out_buffer.type.type;
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = in_buffer.obj_ptr;
else
out_buffer.obj_ptr = 0;
+ } else /* op == get_functor_type_tag */ {
+ out_buffer.type.type = &typeid(Functor);
+ out_buffer.type.const_qualified = false;
+ out_buffer.type.volatile_qualified = false;
}
}
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
}
+ // For member pointers, we use the small-object optimization buffer.
+ static inline void
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ functor_manager_operation_type op, member_ptr_tag)
+ {
+ manager(in_buffer, out_buffer, op, mpl::true_());
+ }
+
public:
/* Dispatch to an appropriate manager based on whether we have a
function pointer or a function object pointer. */
typedef typename get_function_tag<functor_type>::type tag_type;
switch (op) {
case get_functor_type_tag:
- out_buffer.const_obj_ptr = &typeid(functor_type);
+ out_buffer.type.type = &typeid(functor_type);
+ out_buffer.type.const_qualified = false;
+ out_buffer.type.volatile_qualified = false;
return;
default:
// Get back to the original pointer type
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
out_buffer.obj_ptr = new_f;
+ } else if (op == move_functor_tag) {
+ out_buffer.obj_ptr = in_buffer.obj_ptr;
+ in_buffer.obj_ptr = 0;
} else if (op == destroy_functor_tag) {
/* Cast from the void pointer to the functor_wrapper_type */
functor_wrapper_type* victim =
wrapper_allocator.destroy(victim);
wrapper_allocator.deallocate(victim,1);
out_buffer.obj_ptr = 0;
- } else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ } else if (op == check_functor_type_tag) {
+ const BOOST_FUNCTION_STD_NS::type_info& check_type
+ = *out_buffer.type.type;
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = in_buffer.obj_ptr;
else
out_buffer.obj_ptr = 0;
+ } else /* op == get_functor_type_tag */ {
+ out_buffer.type.type = &typeid(Functor);
+ out_buffer.type.const_qualified = false;
+ out_buffer.type.volatile_qualified = false;
}
}
typedef typename get_function_tag<functor_type>::type tag_type;
switch (op) {
case get_functor_type_tag:
- out_buffer.const_obj_ptr = &typeid(functor_type);
+ out_buffer.type.type = &typeid(functor_type);
+ out_buffer.type.const_qualified = false;
+ out_buffer.type.volatile_qualified = false;
return;
default:
*/
struct vtable_base
{
- vtable_base() : manager(0) { }
void (*manager)(const function_buffer& in_buffer,
function_buffer& out_buffer,
functor_manager_operation_type op);
detail::function::function_buffer type;
vtable->manager(functor, type, detail::function::get_functor_type_tag);
- return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
+ return *type.type.type;
}
template<typename Functor>
if (!vtable) return 0;
detail::function::function_buffer type_result;
- type_result.const_obj_ptr = &typeid(Functor);
+ type_result.type.type = &typeid(Functor);
+ type_result.type.const_qualified = is_const<Functor>::value;
+ type_result.type.volatile_qualified = is_volatile<Functor>::value;
vtable->manager(functor, type_result,
detail::function::check_functor_type_tag);
return static_cast<Functor*>(type_result.obj_ptr);
if (!vtable) return 0;
detail::function::function_buffer type_result;
- type_result.const_obj_ptr = &typeid(Functor);
+ type_result.type.type = &typeid(Functor);
+ type_result.type.const_qualified = true;
+ type_result.type.volatile_qualified = is_volatile<Functor>::value;
vtable->manager(functor, type_result,
detail::function::check_functor_type_tag);
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_MEMBER_INVOKER \
+ BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
+ BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
+ BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_INVOKER \
+ BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
#ifndef BOOST_NO_VOID_RETURNS
}
};
+#if BOOST_FUNCTION_NUM_ARGS > 0
+ /* Handle invocation of member pointers. */
+ template<
+ typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_PARMS
+ >
+ struct BOOST_FUNCTION_MEMBER_INVOKER
+ {
+ static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_PARMS)
+
+ {
+ MemberPtr* f =
+ reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+ return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
+ }
+ };
+
+ template<
+ typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_PARMS
+ >
+ struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
+ {
+ static BOOST_FUNCTION_VOID_RETURN_TYPE
+ invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_PARMS)
+
+ {
+ MemberPtr* f =
+ reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+ BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
+ }
+ };
+#endif
+
template<
typename FunctionPtr,
typename R BOOST_FUNCTION_COMMA
>::type type;
};
+#if BOOST_FUNCTION_NUM_ARGS > 0
+ /* Retrieve the appropriate invoker for a member pointer. */
+ template<
+ typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_PARMS
+ >
+ struct BOOST_FUNCTION_GET_MEMBER_INVOKER
+ {
+ typedef typename mpl::if_c<(is_void<R>::value),
+ BOOST_FUNCTION_VOID_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >,
+ BOOST_FUNCTION_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >
+ >::type type;
+ };
+#endif
+
+ /* Given the tag returned by get_function_tag, retrieve the
+ actual invoker that will be used for the given function
+ object.
+
+ Each specialization contains an "apply" nested class template
+ that accepts the function object, return type, function
+ argument types, and allocator. The resulting "apply" class
+ contains two typedefs, "invoker_type" and "manager_type",
+ which correspond to the invoker and manager types. */
+ template<typename Tag>
+ struct BOOST_FUNCTION_GET_INVOKER { };
+
+ /* Retrieve the invoker for a function pointer. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
+ {
+ template<typename FunctionPtr,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+ FunctionPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<FunctionPtr> manager_type;
+ };
+
+ template<typename FunctionPtr,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply_a
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+ FunctionPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<FunctionPtr> manager_type;
+ };
+ };
+
+#if BOOST_FUNCTION_NUM_ARGS > 0
+ /* Retrieve the invoker for a member pointer. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
+ {
+ template<typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<MemberPtr> manager_type;
+ };
+
+ template<typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply_a
+ {
+ typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<MemberPtr> manager_type;
+ };
+ };
+#endif
+
+ /* Retrieve the invoker for a function object. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
+ {
+ template<typename FunctionObj,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+ FunctionObj,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<FunctionObj> manager_type;
+ };
+
+ template<typename FunctionObj,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply_a
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+ FunctionObj,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+ };
+ };
+
+ /* Retrieve the invoker for a reference to a function object. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
+ {
+ template<typename RefWrapper,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+ typename RefWrapper::type,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef reference_manager<typename RefWrapper::type> manager_type;
+ };
+
+ template<typename RefWrapper,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply_a
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+ typename RefWrapper::type,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef reference_manager<typename RefWrapper::type> manager_type;
+ };
+ };
+
+
/**
- * vtable for a specific boost::function instance.
+ * vtable for a specific boost::function instance. This
+ * structure must be an aggregate so that we can use static
+ * initialization in boost::function's assign_to and assign_to_a
+ * members. It therefore cannot have any constructors,
+ * destructors, base classes, etc.
*/
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
- struct BOOST_FUNCTION_VTABLE : vtable_base
+ struct BOOST_FUNCTION_VTABLE
{
#ifndef BOOST_NO_VOID_RETURNS
typedef R result_type;
BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS);
- template<typename F>
- BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
- {
- init(f);
- }
- template<typename F,typename Allocator>
- BOOST_FUNCTION_VTABLE(F f, Allocator) : vtable_base(), invoker(0)
- {
- init_a<Allocator>(f);
- }
-
template<typename F>
bool assign_to(F f, function_buffer& functor)
{
void clear(function_buffer& functor)
{
- if (manager)
- manager(functor, functor, destroy_functor_tag);
+ if (base.manager)
+ base.manager(functor, functor, destroy_functor_tag);
}
private:
- template<typename F>
- void init(F f)
- {
- typedef typename get_function_tag<F>::type tag;
- init(f, tag());
- }
- template<typename Allocator,typename F>
- void init_a(F f)
- {
- typedef typename get_function_tag<F>::type tag;
- init_a<Allocator>(f, tag());
- }
-
// Function pointers
- template<typename FunctionPtr>
- void init(FunctionPtr /*f*/, function_ptr_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
- FunctionPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &functor_manager<FunctionPtr>::manage;
- }
- template<typename Allocator,typename FunctionPtr>
- void init_a(FunctionPtr f, function_ptr_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
- FunctionPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &functor_manager_a<FunctionPtr, Allocator>::manage;
- }
-
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
// Member pointers
#if BOOST_FUNCTION_NUM_ARGS > 0
- template<typename MemberPtr>
- void init(MemberPtr f, member_ptr_tag)
- {
- // DPG TBD: Add explicit support for member function
- // objects, so we invoke through mem_fn() but we retain the
- // right target_type() values.
- this->init(mem_fn(f));
- }
- template<typename Allocator,typename MemberPtr>
- void init_a(MemberPtr f, member_ptr_tag)
- {
- // DPG TBD: Add explicit support for member function
- // objects, so we invoke through mem_fn() but we retain the
- // right target_type() values.
- this->init_a<Allocator>(mem_fn(f));
- }
-
template<typename MemberPtr>
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
{
#endif // BOOST_FUNCTION_NUM_ARGS > 0
// Function objects
- template<typename FunctionObj>
- void init(FunctionObj /*f*/, function_obj_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
- FunctionObj,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &functor_manager<FunctionObj>::manage;
- }
- template<typename Allocator,typename FunctionObj>
- void init_a(FunctionObj /*f*/, function_obj_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
- FunctionObj,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &functor_manager_a<FunctionObj, Allocator>::manage;
- }
-
// Assign to a function object using the small object optimization
template<typename FunctionObj>
void
}
// Reference to a function object
- template<typename FunctionObj>
- void
- init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
- FunctionObj,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &reference_manager<FunctionObj>::get;
- }
- template<typename Allocator,typename FunctionObj>
- void
- init_a(const reference_wrapper<FunctionObj>& f, function_obj_ref_tag)
- {
- init(f,function_obj_ref_tag());
- }
-
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag)
{
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
- // DPG TBD: We might need to detect constness of
- // FunctionObj to assign into obj_ptr or const_obj_ptr to
- // be truly legit, but no platform in existence makes
- // const void* different from void*.
- functor.const_obj_ptr = f.get_pointer();
+ functor.obj_ref.obj_ptr = (void *)f.get_pointer();
+ functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+ functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
return true;
} else {
return false;
}
public:
+ vtable_base base;
invoker_type invoker;
};
} // end namespace function
if (&other == this)
return;
- BOOST_FUNCTION_FUNCTION tmp = *this;
- *this = other;
- other = tmp;
+ BOOST_FUNCTION_FUNCTION tmp;
+ tmp.move_assign(*this);
+ this->move_assign(other);
+ other.move_assign(tmp);
}
// Clear out a target, if there is one
void clear()
{
if (vtable) {
- static_cast<vtable_type*>(vtable)->clear(this->functor);
+ reinterpret_cast<vtable_type*>(vtable)->clear(this->functor);
vtable = 0;
}
}
template<typename Functor>
void assign_to(Functor f)
{
- static vtable_type stored_vtable(f);
- if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
+ using detail::function::vtable_base;
+
+ typedef typename detail::function::get_function_tag<Functor>::type tag;
+ typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+ typedef typename get_invoker::
+ template apply<Functor, R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS>
+ handler_type;
+
+ typedef typename handler_type::invoker_type invoker_type;
+ typedef typename handler_type::manager_type manager_type;
+
+ // Note: it is extremely important that this initialization use
+ // static initialization. Otherwise, we will have a race
+ // condition here in multi-threaded code. See
+ // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
+ static vtable_type stored_vtable =
+ { { &manager_type::manage }, &invoker_type::invoke };
+
+ if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
else vtable = 0;
}
+
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
- static vtable_type stored_vtable(f,a);
- if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable;
+ using detail::function::vtable_base;
+
+ typedef typename detail::function::get_function_tag<Functor>::type tag;
+ typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+ typedef typename get_invoker::
+ template apply_a<Functor, R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS,
+ Allocator>
+ handler_type;
+
+ typedef typename handler_type::invoker_type invoker_type;
+ typedef typename handler_type::manager_type manager_type;
+
+ // Note: it is extremely important that this initialization use
+ // static initialization. Otherwise, we will have a race
+ // condition here in multi-threaded code. See
+ // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
+ static vtable_type stored_vtable =
+ { { &manager_type::manage }, &invoker_type::invoke };
+
+ if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable.base;
else vtable = 0;
}
+
+ // Moves the value from the specified argument to *this. If the argument
+ // has its function object allocated on the heap, move_assign will pass
+ // its buffer to *this, and set the argument's buffer pointer to NULL.
+ void move_assign(BOOST_FUNCTION_FUNCTION& f)
+ {
+ if (&f == this)
+ return;
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+ try {
+#endif
+ if (!f.empty()) {
+ this->vtable = f.vtable;
+ f.vtable->manager(f.functor, this->functor,
+ boost::detail::function::move_functor_tag);
+ f.vtable = 0;
+#if !defined(BOOST_NO_EXCEPTIONS)
+ } else {
+ clear();
+ }
+ } catch (...) {
+ vtable = 0;
+ throw;
+ }
+#endif
+ }
};
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
if (this->empty())
boost::throw_exception(bad_function_call());
- return static_cast<vtable_type*>(vtable)->invoker
+ return reinterpret_cast<const vtable_type*>(vtable)->invoker
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
}
#endif
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#ifndef GET_POINTER_DWA20021219_HPP
# define GET_POINTER_DWA20021219_HPP
-# include <memory>
+// In order to avoid circular dependencies with Boost.TR1
+// we make sure that our include of <memory> doesn't try to
+// pull in the TR1 headers: that's why we use this header
+// rather than including <memory> directly:
+# include <boost/config/no_tr1/memory.hpp> // std::auto_ptr
namespace boost {
//
// Copyright (c) 2001, 2002 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
//
-#include <boost/config.hpp>
-
-#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/sp_convertible.hpp>
-
-#include <boost/config/no_tr1/functional.hpp> // for std::less
-
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
-#include <iosfwd> // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-
-
-namespace boost
-{
-
-//
-// intrusive_ptr
-//
-// A smart pointer that uses intrusive reference counting.
-//
-// Relies on unqualified calls to
-//
-// void intrusive_ptr_add_ref(T * p);
-// void intrusive_ptr_release(T * p);
-//
-// (p != 0)
-//
-// The object is responsible for destroying itself.
-//
-
-template<class T> class intrusive_ptr
-{
-private:
-
- typedef intrusive_ptr this_type;
-
-public:
-
- typedef T element_type;
-
- intrusive_ptr(): p_(0)
- {
- }
-
- intrusive_ptr(T * p, bool add_ref = true): p_(p)
- {
- if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_);
- }
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
- template<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- intrusive_ptr( intrusive_ptr<U> const & rhs, typename detail::sp_enable_if_convertible<U,T>::type = detail::sp_empty() )
-
-#else
-
- intrusive_ptr( intrusive_ptr<U> const & rhs )
-
-#endif
- : p_( rhs.get() )
- {
- if( p_ != 0 ) intrusive_ptr_add_ref( p_ );
- }
-
-#endif
-
- intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_)
- {
- if(p_ != 0) intrusive_ptr_add_ref(p_);
- }
-
- ~intrusive_ptr()
- {
- if(p_ != 0) intrusive_ptr_release(p_);
- }
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
- template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
- {
- this_type(rhs).swap(*this);
- return *this;
- }
-
-#endif
-
- intrusive_ptr & operator=(intrusive_ptr const & rhs)
- {
- this_type(rhs).swap(*this);
- return *this;
- }
-
- intrusive_ptr & operator=(T * rhs)
- {
- this_type(rhs).swap(*this);
- return *this;
- }
-
- void reset()
- {
- this_type().swap( *this );
- }
-
- void reset( T * rhs )
- {
- this_type( rhs ).swap( *this );
- }
-
- T * get() const
- {
- return p_;
- }
-
- T & operator*() const
- {
- BOOST_ASSERT( p_ != 0 );
- return *p_;
- }
-
- T * operator->() const
- {
- BOOST_ASSERT( p_ != 0 );
- return p_;
- }
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
- operator bool () const
- {
- return p_ != 0;
- }
-
-#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
- typedef T * (this_type::*unspecified_bool_type)() const;
-
- operator unspecified_bool_type() const // never throws
- {
- return p_ == 0? 0: &this_type::get;
- }
-
-#else
-
- typedef T * this_type::*unspecified_bool_type;
-
- operator unspecified_bool_type () const
- {
- return p_ == 0? 0: &this_type::p_;
- }
-
-#endif
-
- // operator! is a Borland-specific workaround
- bool operator! () const
- {
- return p_ == 0;
- }
-
- void swap(intrusive_ptr & rhs)
- {
- T * tmp = p_;
- p_ = rhs.p_;
- rhs.p_ = tmp;
- }
-
-private:
-
- T * p_;
-};
-
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
-{
- return a.get() != b.get();
-}
-
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
-{
- return a.get() == b;
-}
-
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
-{
- return a.get() != b;
-}
-
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)
-{
- return a == b.get();
-}
-
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)
-{
- return a != b.get();
-}
-
-#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
-
-// Resolve the ambiguity between our op!= and the one in rel_ops
-
-template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
-{
- return a.get() != b.get();
-}
-
-#endif
-
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
-{
- return std::less<T *>()(a.get(), b.get());
-}
-
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
-{
- lhs.swap(rhs);
-}
-
-// mem_fn support
-
-template<class T> T * get_pointer(intrusive_ptr<T> const & p)
-{
- return p.get();
-}
-
-template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
-{
- return static_cast<T *>(p.get());
-}
-
-template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
-{
- return const_cast<T *>(p.get());
-}
-
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
-{
- return dynamic_cast<T *>(p.get());
-}
-
-// operator<<
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) && (__GNUC__ < 3) )
-
-template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
-{
- os << p.get();
- return os;
-}
-
-#else
-
-// in STLport's no-iostreams mode no iostream symbols can be used
-#ifndef _STLP_NO_IOSTREAMS
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
-// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
-using std::basic_ostream;
-template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# else
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# endif
-{
- os << p.get();
- return os;
-}
-
-#endif // _STLP_NO_IOSTREAMS
-
-#endif // __GNUC__ < 3
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
+#include <boost/smart_ptr/intrusive_ptr.hpp>
#endif // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531)) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \
|| (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
|| BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
private:
typename super_t::reference dereference() const
{
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
return const_cast<super_t::reference>(**this->base());
# else
return **this->base();
#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
# include <boost/type_traits/remove_reference.hpp>
-#else
+
+# if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+# include <boost/type_traits/add_reference.hpp>
+# endif
+
+#else
# include <boost/type_traits/add_reference.hpp>
-#endif
+#endif
#include <boost/iterator/detail/config_def.hpp>
//
class iterator_core_access
{
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
// Tasteless as this may seem, making all members public allows member templates
// to work in the absence of member template friends.
public:
#include <climits>
#include <cstddef>
#include <istream>
-#include <locale>
#include <string>
#include <typeinfo>
+#include <exception>
#include <boost/config.hpp>
#include <boost/limits.hpp>
#include <boost/mpl/if.hpp>
#include <boost/throw_exception.hpp>
#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
#include <boost/call_traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/lcast_precision.hpp>
+#include <boost/detail/workaround.hpp>
+
+#ifndef BOOST_NO_STD_LOCALE
+#include <locale>
+#endif
#ifdef BOOST_NO_STRINGSTREAM
#include <strstream>
#if defined(BOOST_NO_STRINGSTREAM) || \
defined(BOOST_NO_STD_WSTRING) || \
defined(BOOST_NO_STD_LOCALE)
-#define DISABLE_WIDE_CHAR_SUPPORT
+#define BOOST_LCAST_NO_WCHAR_T
#endif
namespace boost
{
// exception used to indicate runtime lexical_cast failure
class bad_lexical_cast : public std::bad_cast
+
+#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
+ // under bcc32 5.5.1 bad_cast doesn't derive from exception
+ , public std::exception
+#endif
+
{
public:
bad_lexical_cast() :
- source(&typeid(void)), target(&typeid(void))
+#ifndef BOOST_NO_TYPEID
+ source(&typeid(void)), target(&typeid(void))
+#else
+ source(0), target(0) // this breaks getters
+#endif
{
}
+
bad_lexical_cast(
const std::type_info &source_type_arg,
const std::type_info &target_type_arg) :
source(&source_type_arg), target(&target_type_arg)
{
}
+
const std::type_info &source_type() const
{
return *source;
{
return *target;
}
+
virtual const char *what() const throw()
{
return "bad lexical cast: "
};
#endif
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
template<>
struct stream_char<wchar_t>
// lcast_src_length<char, signed char const*>
// lcast_src_length<char, unsigned char const*>
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_src_length<wchar_t, bool>
{
static void check_coverage() {}
};
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_src_length<wchar_t, wchar_t const*>
{
static void check_coverage() {}
};
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_src_length< wchar_t, std::basic_string<wchar_t> >
{
#endif
};
-#define BOOST_AUX_LEXICAL_CAST_DEF1(CharT, T) template<> \
- struct lcast_src_length<CharT, T> : lcast_src_length_integral<T> \
+#define BOOST_LCAST_DEF1(CharT, T) \
+ template<> struct lcast_src_length<CharT, T> \
+ : lcast_src_length_integral<T> \
{ static void check_coverage() {} };
-#ifdef DISABLE_WIDE_CHAR_SUPPORT
-#define BOOST_AUX_LEXICAL_CAST_DEF(T) BOOST_AUX_LEXICAL_CAST_DEF1(char, T)
+#ifdef BOOST_LCAST_NO_WCHAR_T
+#define BOOST_LCAST_DEF(T) BOOST_LCAST_DEF1(char, T)
#else
-#define BOOST_AUX_LEXICAL_CAST_DEF(T) \
- BOOST_AUX_LEXICAL_CAST_DEF1(char, T) \
- BOOST_AUX_LEXICAL_CAST_DEF1(wchar_t, T)
+#define BOOST_LCAST_DEF(T) \
+ BOOST_LCAST_DEF1(char, T) \
+ BOOST_LCAST_DEF1(wchar_t, T)
#endif
- BOOST_AUX_LEXICAL_CAST_DEF(short)
- BOOST_AUX_LEXICAL_CAST_DEF(unsigned short)
- BOOST_AUX_LEXICAL_CAST_DEF(int)
- BOOST_AUX_LEXICAL_CAST_DEF(unsigned int)
- BOOST_AUX_LEXICAL_CAST_DEF(long)
- BOOST_AUX_LEXICAL_CAST_DEF(unsigned long)
+ BOOST_LCAST_DEF(short)
+ BOOST_LCAST_DEF(unsigned short)
+ BOOST_LCAST_DEF(int)
+ BOOST_LCAST_DEF(unsigned int)
+ BOOST_LCAST_DEF(long)
+ BOOST_LCAST_DEF(unsigned long)
#if defined(BOOST_HAS_LONG_LONG)
- BOOST_AUX_LEXICAL_CAST_DEF(boost::ulong_long_type)
- BOOST_AUX_LEXICAL_CAST_DEF(boost::long_long_type )
+ BOOST_LCAST_DEF(boost::ulong_long_type)
+ BOOST_LCAST_DEF(boost::long_long_type )
#elif defined(BOOST_HAS_MS_INT64)
- BOOST_AUX_LEXICAL_CAST_DEF(unsigned __int64)
- BOOST_AUX_LEXICAL_CAST_DEF( __int64)
+ BOOST_LCAST_DEF(unsigned __int64)
+ BOOST_LCAST_DEF( __int64)
#endif
-#undef BOOST_AUX_LEXICAL_CAST_DEF
-#undef BOOST_AUX_LEXICAL_CAST_DEF1
+#undef BOOST_LCAST_DEF
+#undef BOOST_LCAST_DEF1
#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
// Helper for floating point types.
static void check_coverage() {}
};
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_src_length<wchar_t,float>
: lcast_src_length_floating<float>
static void check_coverage() {}
};
-#endif // #ifndef DISABLE_WIDE_CHAR_SUPPORT
+#endif // #ifndef BOOST_LCAST_NO_WCHAR_T
#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
}
BOOST_STATIC_CONSTANT(char, minus = '-');
};
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_char_constants<wchar_t>
{
# pragma warning( push )
// C4146: unary minus operator applied to unsigned type, result still unsigned
# pragma warning( disable : 4146 )
+#elif defined( __BORLANDC__ )
+# pragma option push -w-8041
#endif
-
- inline unsigned int lcast_to_unsigned(int value)
- {
- unsigned int uval = value;
- return value < 0 ? -uval : uval;
- }
-
- inline unsigned long lcast_to_unsigned(long value)
- {
- unsigned long uval = value;
- return value < 0 ? -uval : uval;
- }
-
-#if defined(BOOST_HAS_LONG_LONG)
- inline boost::ulong_long_type lcast_to_unsigned(boost::long_long_type v)
- {
- boost::ulong_long_type uval = v;
- return v < 0 ? -uval : uval;
- }
-#elif defined(BOOST_HAS_MS_INT64)
- inline unsigned __int64 lcast_to_unsigned(__int64 value)
+ template<class T>
+ inline
+ BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value)
{
- unsigned __int64 uval = value;
- return value < 0 ? -uval : uval;
+ typedef BOOST_DEDUCED_TYPENAME make_unsigned<T>::type result_type;
+ result_type uvalue = static_cast<result_type>(value);
+ return value < 0 ? -uvalue : uvalue;
}
-#endif
-
#if (defined _MSC_VER)
-# pragma warning( pop ) // C4146: unary minus operator applied to unsigned type,
- // result still unsigned
+# pragma warning( pop )
+#elif defined( __BORLANDC__ )
+# pragma option pop
#endif
}
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
#endif
- CharT thousands_sep = 0;
-#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- char const* grouping = "";
- std::size_t const grouping_size = 0;
-#else
+#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+ // TODO: use BOOST_NO_STD_LOCALE
std::locale loc;
typedef std::numpunct<CharT> numpunct;
numpunct const& np = BOOST_USE_FACET(numpunct, loc);
std::string const& grouping = np.grouping();
std::string::size_type const grouping_size = grouping.size();
-
- if(grouping_size)
- thousands_sep = np.thousands_sep();
-#endif
-
+ CharT thousands_sep = grouping_size ? np.thousands_sep() : 0;
std::string::size_type group = 0; // current group number
char last_grp_size = grouping[0] <= 0 ? CHAR_MAX : grouping[0];
// a) Since grouping is const, grouping[grouping.size()] returns 0.
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
#endif
+
+ char left = last_grp_size;
+#endif
+
typedef typename Traits::int_type int_type;
CharT const czero = lcast_char_constants<CharT>::zero;
int_type const zero = Traits::to_int_type(czero);
- char left = last_grp_size;
-
do
{
+#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
if(left == 0)
{
++group;
}
--left;
+#endif
+
--finish;
int_type const digit = static_cast<int_type>(n % 10U);
Traits::assign(*finish, Traits::to_char_type(zero + digit));
stream.str().swap(output);
return true;
}
- #ifndef DISABLE_WIDE_CHAR_SUPPORT
+ #ifndef BOOST_LCAST_NO_WCHAR_T
bool operator>>(std::wstring &output)
{
stream.str().swap(output);
Traits::assign(*p, ch);
}
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
static void widen_and_assign(wchar_t* p, char ch)
{
+ // TODO: use BOOST_NO_STD_LOCALE
std::locale loc;
wchar_t w = BOOST_USE_FACET(std::ctype<wchar_t>, loc).widen(ch);
Traits::assign(*p, w);
public:
- lexical_stream_limited_src(CharT* start, CharT* finish)
- : start(start)
- , finish(finish)
+ lexical_stream_limited_src(CharT* sta, CharT* fin)
+ : start(sta)
+ , finish(fin)
{}
public: // output
bool operator<<(bool);
bool operator<<(char);
-#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
bool operator<<(wchar_t);
#endif
bool operator<<(CharT const*);
bool operator>>(std::string&);
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
bool operator>>(std::wstring&);
#endif
return true;
}
-#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
wchar_t ch)
inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
unsigned short n)
{
- start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
+ start = lcast_put_unsigned<Traits>(n, finish);
return true;
}
return true;
}
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>(
std::wstring& str)
BOOST_STATIC_CONSTANT(bool, value = false);
};
-#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
template<>
struct lcast_streambuf_for_target<wchar_t>
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<class Traits, class Alloc>
struct lcast_streambuf_for_target<
std::basic_string<wchar_t,Traits,Alloc> >
BOOST_STATIC_CONSTANT(bool, value = false);
};
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
+#ifndef BOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_streambuf_for_target<std::wstring>
{
if (interpreter >> result)
return result;
}
+#ifndef BOOST_NO_TYPEID
throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
+#else
+ throw_exception(bad_lexical_cast());
+#endif
return Target(); // normally never reached (throw_exception)
}
}
Target result;
if(!(interpreter << arg && interpreter >> result))
+#ifndef BOOST_NO_TYPEID
throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
+#else
+ throw_exception(bad_lexical_cast());
+#endif
return result;
}
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-#undef DISABLE_WIDE_CHAR_SUPPORT
+#undef BOOST_LCAST_NO_WCHAR_T
#endif
//
// use this header as a workaround for missing <limits>
-// See http://www.boost.org/libs/utility/limits.html for documentation.
+// See http://www.boost.org/libs/compatibility/index.html for documentation.
#ifndef BOOST_LIMITS
#define BOOST_LIMITS
//
// mem_fn.hpp - a generalization of std::mem_fun[_ref]
//
-// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-// Copyright (c) 2001 David Abrahams
-// Copyright (c) 2003-2005 Peter Dimov
+// Copyright (c) 2009 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
//
-#include <boost/config.hpp>
-#include <boost/get_pointer.hpp>
-#include <boost/detail/workaround.hpp>
-
-namespace boost
-{
-
-#if defined(BOOST_NO_VOID_RETURNS)
-
-#define BOOST_MEM_FN_CLASS_F , class F
-#define BOOST_MEM_FN_TYPEDEF(X)
-
-namespace _mfi // mem_fun_impl
-{
-
-template<class V> struct mf
-{
-
-#define BOOST_MEM_FN_RETURN return
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<V>
-
-template<> struct mf<void>
-{
-
-#define BOOST_MEM_FN_RETURN
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<void>
-
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF_F
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_NAME2(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-} // namespace _mfi
-
-#else // #ifdef BOOST_NO_VOID_RETURNS
-
-#define BOOST_MEM_FN_CLASS_F
-#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
-
-namespace _mfi
-{
-
-#define BOOST_MEM_FN_RETURN return
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-} // namespace _mfi
-
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF
-
-#endif // #ifdef BOOST_NO_VOID_RETURNS
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-// data member support
-
-namespace _mfi
-{
-
-template<class R, class T> class dm
-{
-public:
-
- typedef R const & result_type;
- typedef T const * argument_type;
-
-private:
-
- typedef R (T::*F);
- F f_;
-
- template<class U> R const & call(U & u, T const *) const
- {
- return (u.*f_);
- }
-
- template<class U> R const & call(U & u, void const *) const
- {
- return (get_pointer(u)->*f_);
- }
-
-public:
-
- explicit dm(F f): f_(f) {}
-
- R & operator()(T * p) const
- {
- return (p->*f_);
- }
-
- R const & operator()(T const * p) const
- {
- return (p->*f_);
- }
-
- template<class U> R const & operator()(U const & u) const
- {
- return call(u, &u);
- }
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, < 0x3200)
-
- R & operator()(T & t) const
- {
- return (t.*f_);
- }
-
- R const & operator()(T const & t) const
- {
- return (t.*f_);
- }
-
-#endif
-
- bool operator==(dm const & rhs) const
- {
- return f_ == rhs.f_;
- }
-
- bool operator!=(dm const & rhs) const
- {
- return f_ != rhs.f_;
- }
-};
-
-} // namespace _mfi
-
-template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
-{
- return _mfi::dm<R, T>(f);
-}
-
-} // namespace boost
+#include <boost/bind/mem_fn.hpp>
#endif // #ifndef BOOST_MEM_FN_HPP_INCLUDED
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: O1_size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-01-19 10:20:21 -0500 (Wed, 19 Jan 2005) $
-// $Revision: 26742 $
+// $Id: accumulate.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: advance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/advance_fwd.hpp>
#include <boost/mpl/less.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: advance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/common_name_wknd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: alias.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace {
namespace mpl = boost::mpl;
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: always.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/preprocessor/def_params_tail.hpp>
#include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: and.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/apply_fwd.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
# define i_ BOOST_PP_FRAME_ITERATION(1)
# undef i_
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
-// $Revision: 30670 $
+// $Id: apply_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/aux_/na.hpp>
#ifndef BOOST_MPL_APPLY_WRAP_HPP_INCLUDED
#define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 11:56:59 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24892 $
+// $Id: apply_wrap.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
+// $Date: 2008-10-11 02:50:46 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49272 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/aux_/arity.hpp>
# include <boost/mpl/aux_/preprocessor/params.hpp>
# include <boost/mpl/aux_/preprocessor/enum.hpp>
# include <boost/mpl/aux_/preprocessor/add.hpp>
+# include <boost/mpl/aux_/config/bcc.hpp>
+# include <boost/mpl/aux_/config/ctps.hpp>
# include <boost/mpl/aux_/config/dtp.hpp>
# include <boost/mpl/aux_/config/eti.hpp>
-# include <boost/mpl/aux_/config/ctps.hpp>
# include <boost/mpl/aux_/config/msvc.hpp>
# include <boost/mpl/aux_/config/workaround.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
# define i_ BOOST_PP_FRAME_ITERATION(1)
# define j_ BOOST_PP_FRAME_ITERATION(2)
+#if i_ == 0 && j_ == 0 \
+ && defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \
+ && !defined(BOOST_MPL_CFG_NO_HAS_APPLY)
+
+template< typename F, bool F_has_apply >
+struct apply_wrap_impl0_bcb {
+ typedef typename F::template apply< na > type;
+};
+
+template< typename F >
+struct apply_wrap_impl0_bcb< F, true > {
+ typedef typename F::apply type;
+};
+
+template<
+ typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+ >
+struct BOOST_PP_CAT(apply_wrap_impl,i_)<
+ BOOST_MPL_PP_ADD(i_, j_)
+ , F
+ BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T)
+ >
+{
+ typedef apply_wrap_impl0_bcb< F, aux::has_apply< F >::value >::type type;
+};
+#else
+
template<
typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
>
> type;
};
+#endif
+
# undef j_
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-21 09:48:10 -0400 (Tue, 21 Sep 2004) $
-// $Revision: 25308 $
+// $Id: arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/arg_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: arg_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: arithmetic.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/plus.hpp>
#include <boost/mpl/minus.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: as_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/single_view.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/not.hpp>
#include <boost/mpl/aux_/value_wknd.hpp>
#include <cstddef>
-#if BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| (BOOST_MPL_CFG_GCC != 0) \
|| BOOST_WORKAROUND(__IBMCPP__, <= 600)
# define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES
#if BOOST_WORKAROUND(__MWERKS__, < 0x3202) \
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
- || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
# define BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER
#endif
// agurt, 10/nov/06: use enums for Borland (which cannot cope with static constants)
// and GCC (which issues "unused variable" warnings when static constants are used
// at a function scope)
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| (BOOST_MPL_CFG_GCC != 0)
# define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr }
#else
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 21:33:47 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24897 $
+// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/aux_/at_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: at_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: O1_size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/long.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: adl_barrier.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/adl.hpp>
#include <boost/mpl/aux_/config/gcc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: advance_backward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/prior.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
#define i_ BOOST_PP_FRAME_ITERATION(1)
template<>
# undef AUX778076_ITER_1
# undef AUX778076_ITER_0
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: advance_forward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
#define i_ BOOST_PP_FRAME_ITERATION(1)
template<>
# undef AUX778076_ITER_1
# undef AUX778076_ITER_0
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: apply_1st.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: arg_typedef.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/lambda.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: arithmetic_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/dtp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 21:04:02 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26326 $
+// $Id: arity_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/int.hpp>
#include <boost/mpl/limits/arity.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/advance.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: back_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: basic_bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT
#include <boost/mpl/bind.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/sequence_tag_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: common_name_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: comparison_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-16 10:09:12 -0400 (Thu, 16 Sep 2004) $
-// $Revision: 25148 $
+// $Id: adl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/intel.hpp>
#if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) \
&& ( BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
- || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
|| BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) \
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 11:56:59 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24892 $
+// $Id: arrays.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
#if !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
- && ( BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+ && ( BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
)
# define BOOST_MPL_CFG_NO_BIND_TEMPLATE
#ifndef BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED
-// Copyright Aleksey Gurtovoy 2001-2004
+// Copyright Aleksey Gurtovoy 2001-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: compiler.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
+// $Date: 2008-10-11 02:50:46 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49272 $
#if !defined(BOOST_MPL_CFG_COMPILER_DIR)
# elif BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304))
# define BOOST_MPL_CFG_COMPILER_DIR gcc
-# elif BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
# define BOOST_MPL_CFG_COMPILER_DIR bcc551
-# else
+# elseif BOOST_WORKAROUND(__BORLANDC__, >= 0x590)
# define BOOST_MPL_CFG_COMPILER_DIR bcc
+# else
+# define BOOST_MPL_CFG_COMPILER_DIR bcc_pre590
# endif
# elif BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
#include <boost/config.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: dependent_nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/gcc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: dmc_ambiguous_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: dtp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& BOOST_WORKAROUND(__BORLANDC__, >= 0x560) \
- && BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+ && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# define BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES
#if !defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& ( BOOST_WORKAROUND(__MWERKS__, <= 0x3001) \
- || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \
)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: eti.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: forwarding.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
- && BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+ && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# define BOOST_MPL_CFG_NO_NESTED_FORWARDING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: gcc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if defined(__GNUC__) && !defined(__EDG_VERSION__)
# define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-13 02:10:10 -0400 (Mon, 13 Sep 2004) $
-// $Revision: 25029 $
+// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/has_xxx.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 11:56:59 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24892 $
+// $Id: has_xxx.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/overload_resolution.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: integral.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
#if !defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
- && BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+ && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# define BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: intel.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// BOOST_INTEL_CXX_VERSION is defined here:
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/ttp.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: msvc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// BOOST_MSVC is defined here:
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: msvc_typename.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-06-14 08:42:08 -0400 (Tue, 14 Jun 2005) $
-// $Revision: 29558 $
+// $Id: operators.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/gcc.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
#if !defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) \
&& ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, <= 0x600) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 245) \
|| BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, <= 0x0295) \
|| BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: overload_resolution.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: pp_counter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_AUX_PP_COUNTER)
# include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: preprocessor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
#if !defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) \
&& ( BOOST_WORKAROUND(__MWERKS__, <= 0x3003) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \
+ || BOOST_WORKAROUND(__BORLANDC__, < 0x582) \
|| BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \
)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: static_constant.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
// BOOST_STATIC_CONSTANT is defined here:
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: ttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/gcc.hpp>
#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \
- || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
)
# define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: typeof.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/gcc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: use_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: workaround.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/detail/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: contains_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: count_args.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/expr_if.hpp>
#include <boost/preprocessor/inc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: count_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/count_fwd.hpp>
#include <boost/mpl/count_if.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear.hpp>
#include <boost/mpl/push_front.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_key_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 08:07:57 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24956 $
+// $Id: filter_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/iterator_range.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-24 04:18:08 -0400 (Sun, 24 Oct 2004) $
-// $Revision: 25850 $
+// $Id: fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
# include <boost/mpl/limits/unrolling.hpp>
# include <boost/mpl/aux_/preprocessor/repeat.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: fold_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: fold_pred.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/same_as.hpp>
#include <boost/mpl/apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: front_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 21:10:23 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24896 $
+// $Id: full_lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/lambda_fwd.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
#define i_ BOOST_PP_FRAME_ITERATION(1)
#if i_ > 0
};
#undef i_
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 11:56:59 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24892 $
+// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/aux_/config/has_apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_begin.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_key_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
-// $Revision: 30670 $
+// $Id: has_rebind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/intel.hpp>
# include <boost/mpl/if.hpp>
# include <boost/mpl/bool.hpp>
# include <boost/mpl/aux_/msvc_is_class.hpp>
-#elif BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# include <boost/mpl/if.hpp>
# include <boost/mpl/bool.hpp>
# include <boost/mpl/aux_/yes_no.hpp>
template< typename T > struct has_rebind_tag {};
no_tag operator|(has_rebind_tag<int>, void const volatile*);
-# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
template< typename T >
struct has_rebind
{
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 19:46:57 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35931 $
+// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/compiler.hpp>
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/reverse_fold.hpp>
#include <boost/mpl/iterator_range.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert_range_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/copy.hpp>
#include <boost/mpl/clear.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: inserter_algorithm.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/front_inserter.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: integral_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: is_msvc_eti_arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/yes_no.hpp>
#include <boost/mpl/aux_/config/eti.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iter_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/apply.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iter_fold_if_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/identity.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iter_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iter_push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-01 12:32:41 -0400 (Fri, 01 Oct 2004) $
-// $Revision: 25513 $
+// $Id: joint_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: lambda_arity_param.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/ttp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 08:24:50 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24957 $
+// $Id: lambda_no_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-01-29 02:28:45 -0500 (Mon, 29 Jan 2007) $
-// $Revision: 36830 $
+// $Id: lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/void.hpp>
#include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
-// $Revision: 30670 $
+// $Id: lambda_support.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/lambda.hpp>
typedef BOOST_PP_CAT(name,_rebind) rebind; \
/**/
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \
template< BOOST_MPL_PP_PARAMS(i,typename T) > \
::boost::mpl::aux::yes_tag operator|( \
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-18 23:08:53 -0400 (Sat, 18 Sep 2004) $
-// $Revision: 25205 $
+// $Id: largest_int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: logical_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: msvc_dtw.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:39:23 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26324 $
+// $Id: msvc_eti_base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/is_msvc_eti_arg.hpp>
#include <boost/mpl/aux_/config/eti.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: msvc_is_class.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/if.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: msvc_never_true.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: msvc_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/eti.hpp>
#include <boost/mpl/aux_/is_msvc_eti_arg.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:39:23 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26324 $
+// $Id: na.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/na_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-07-13 09:13:38 -0400 (Wed, 13 Jul 2005) $
-// $Revision: 30043 $
+// $Id: na_assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/na.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:39:23 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26324 $
+// $Id: na_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:39:23 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26324 $
+// $Id: na_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: nested_type_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/gcc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-16 17:43:05 -0500 (Thu, 16 Dec 2004) $
-// $Revision: 26536 $
+// $Id: nttp_decl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/nttp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:39:23 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26324 $
+// $Id: numeric_cast_utils.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/numeric_cast.hpp>
#include <boost/mpl/apply_wrap.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
-// $Revision: 30670 $
+// $Id: numeric_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/numeric_cast.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
# define i_ BOOST_PP_FRAME_ITERATION(1)
# undef i_
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-13 14:25:11 -0400 (Wed, 13 Oct 2004) $
-// $Revision: 25712 $
+// $Id: order_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/order_fwd.hpp>
#include <boost/mpl/if.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-13 14:25:11 -0400 (Wed, 13 Oct 2004) $
-// $Revision: 25712 $
+// $Id: overload_names.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/ptr_to_ref.hpp>
#include <boost/mpl/aux_/config/operators.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: partition_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/apply.hpp>
#include <boost/mpl/eval_if.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_back_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_back_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_front_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header
+// *Preprocessed* version of the main "advance_backward.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header
+// *Preprocessed* version of the main "advance_forward.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/and.hpp" header
+// *Preprocessed* version of the main "and.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/apply.hpp" header
+// *Preprocessed* version of the main "apply.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/apply_fwd.hpp" header
+// *Preprocessed* version of the main "apply_fwd.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/apply_wrap.hpp" header
+// *Preprocessed* version of the main "apply_wrap.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
>
struct apply_wrap_impl0;
+template< typename F, bool F_has_apply >
+struct apply_wrap_impl0_bcb {
+ typedef typename F::template apply<na> type;
+};
+
+template< typename F >
+struct apply_wrap_impl0_bcb< F,true > {
+ typedef typename F::apply type;
+};
+
template<
typename F
>
>
{
- typedef typename F::template apply<
-
-/// since the defaults are "lost", we have to pass *something* even for nullary
-/// metafunction classes
- na
- > type;
+ typedef apply_wrap_impl0_bcb< F, aux::has_apply<F>::value >::type type;
};
template<
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/arg.hpp" header
+// *Preprocessed* version of the main "arg.hpp" header
// -- DO NOT modify by hand!
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header
+// *Preprocessed* version of the main "basic_bind.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/bind.hpp" header
+// *Preprocessed* version of the main "bind.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/bind_fwd.hpp" header
+// *Preprocessed* version of the main "bind_fwd.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/bitand.hpp" header
+// *Preprocessed* version of the main "bitand.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/bitor.hpp" header
+// *Preprocessed* version of the main "bitor.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/bitxor.hpp" header
+// *Preprocessed* version of the main "bitxor.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/deque.hpp" header
+// *Preprocessed* version of the main "deque.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/divides.hpp" header
+// *Preprocessed* version of the main "divides.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/equal_to.hpp" header
+// *Preprocessed* version of the main "equal_to.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header
+// *Preprocessed* version of the main "fold_impl.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header
+// *Preprocessed* version of the main "full_lambda.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/greater.hpp" header
+// *Preprocessed* version of the main "greater.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/greater_equal.hpp" header
+// *Preprocessed* version of the main "greater_equal.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/inherit.hpp" header
+// *Preprocessed* version of the main "inherit.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header
+// *Preprocessed* version of the main "iter_fold_if_impl.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header
+// *Preprocessed* version of the main "iter_fold_impl.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header
+// *Preprocessed* version of the main "lambda_no_ctps.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/less.hpp" header
+// *Preprocessed* version of the main "less.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/less_equal.hpp" header
+// *Preprocessed* version of the main "less_equal.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/list.hpp" header
+// *Preprocessed* version of the main "list.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/list_c.hpp" header
+// *Preprocessed* version of the main "list_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/map.hpp" header
+// *Preprocessed* version of the main "map.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/minus.hpp" header
+// *Preprocessed* version of the main "minus.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/modulus.hpp" header
+// *Preprocessed* version of the main "modulus.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/not_equal_to.hpp" header
+// *Preprocessed* version of the main "not_equal_to.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/or.hpp" header
+// *Preprocessed* version of the main "or.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/placeholders.hpp" header
+// *Preprocessed* version of the main "placeholders.hpp" header
// -- DO NOT modify by hand!
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/plus.hpp" header
+// *Preprocessed* version of the main "plus.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/quote.hpp" header
+// *Preprocessed* version of the main "quote.hpp" header
// -- DO NOT modify by hand!
+namespace boost { namespace mpl {
+
+template< typename T, bool has_type_ >
+struct quote_impl
+
+{
+ typedef typename T::type type;
+};
+
+template< typename T >
+struct quote_impl< T,false >
+{
+ typedef T type;
+};
+
+template<
+ template< typename P1 > class F
+ , typename Tag = void_
+ >
+struct quote1
+{
+ template< typename U1 > struct apply
+
+ {
+ typedef typename quote_impl<
+ F<U1>
+ , aux::has_type< F<U1> >::value
+ >::type type;
+ };
+};
+
+template<
+ template< typename P1, typename P2 > class F
+ , typename Tag = void_
+ >
+struct quote2
+{
+ template< typename U1, typename U2 > struct apply
+
+ {
+ typedef typename quote_impl<
+ F< U1,U2 >
+ , aux::has_type< F< U1,U2 > >::value
+ >::type type;
+ };
+};
+
+template<
+ template< typename P1, typename P2, typename P3 > class F
+ , typename Tag = void_
+ >
+struct quote3
+{
+ template< typename U1, typename U2, typename U3 > struct apply
+
+ {
+ typedef typename quote_impl<
+ F< U1,U2,U3 >
+ , aux::has_type< F< U1,U2,U3 > >::value
+ >::type type;
+ };
+};
+
+template<
+ template< typename P1, typename P2, typename P3, typename P4 > class F
+ , typename Tag = void_
+ >
+struct quote4
+{
+ template<
+ typename U1, typename U2, typename U3, typename U4
+ >
+ struct apply
+
+ {
+ typedef typename quote_impl<
+ F< U1,U2,U3,U4 >
+ , aux::has_type< F< U1,U2,U3,U4 > >::value
+ >::type type;
+ };
+};
+
+template<
+ template<
+ typename P1, typename P2, typename P3, typename P4
+ , typename P5
+ >
+ class F
+ , typename Tag = void_
+ >
+struct quote5
+{
+ template<
+ typename U1, typename U2, typename U3, typename U4
+ , typename U5
+ >
+ struct apply
+
+ {
+ typedef typename quote_impl<
+ F< U1,U2,U3,U4,U5 >
+ , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
+ >::type type;
+ };
+};
+
+}}
+
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header
+// *Preprocessed* version of the main "reverse_fold_impl.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header
+// *Preprocessed* version of the main "reverse_iter_fold_impl.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/set.hpp" header
+// *Preprocessed* version of the main "set.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/set_c.hpp" header
+// *Preprocessed* version of the main "set_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/shift_left.hpp" header
+// *Preprocessed* version of the main "shift_left.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/shift_right.hpp" header
+// *Preprocessed* version of the main "shift_right.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header
+// *Preprocessed* version of the main "template_arity.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/times.hpp" header
+// *Preprocessed* version of the main "times.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/unpack_args.hpp" header
+// *Preprocessed* version of the main "unpack_args.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/vector.hpp" header
+// *Preprocessed* version of the main "vector.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
-// Preprocessed version of "boost/mpl/vector_c.hpp" header
+// *Preprocessed* version of the main "vector_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: add.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: def_params_tail.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/limits/arity.hpp>
#include <boost/mpl/aux_/config/dtp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: default_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: enum.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: ext_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: filter_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define BOOST_MPL_PP_FILTER_PARAMS_0(p1,p2,p3,p4,p5,p6,p7,p8,p9)
#define BOOST_MPL_PP_FILTER_PARAMS_1(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-26 13:13:05 -0400 (Wed, 26 Mar 2008) $
-// $Revision: 43872 $
+// $Id: is_seq.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: partial_spec_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/limits/arity.hpp>
#include <boost/mpl/aux_/preprocessor/params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/seq/subseq.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: repeat.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: sub.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: token_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/preprocessor/is_seq.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: tuple.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0
#define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-06-22 11:20:18 -0400 (Wed, 22 Jun 2005) $
-// $Revision: 29736 $
+// $Id: ptr_to_ref.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/static_cast.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: push_back_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/assert.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: push_front_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/assert.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/aux_/range_c/size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/back_fwd.hpp>
#include <boost/mpl/prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/equal_to.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/aux_/range_c/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-20 12:52:43 -0500 (Mon, 20 Dec 2004) $
-// $Revision: 26558 $
+// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/advance_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/minus.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:39:23 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26324 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-01 12:32:41 -0400 (Fri, 01 Oct 2004) $
-// $Revision: 25513 $
+// $Id: reverse_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-24 04:18:08 -0400 (Sun, 24 Oct 2004) $
-// $Revision: 25850 $
+// $Id: reverse_fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
# include <boost/mpl/limits/unrolling.hpp>
# include <boost/mpl/aux_/preprocessor/repeat.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: reverse_iter_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
///// header body
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-10-04 14:01:35 -0400 (Tue, 04 Oct 2005) $
-// $Revision: 31196 $
+// $Id: sequence_wrapper.hpp 49271 2008-10-11 06:46:00Z agurtovoy $
+// $Date: 2008-10-11 02:46:00 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49271 $
# include <boost/mpl/aux_/config/ctps.hpp>
# include <boost/mpl/aux_/config/static_constant.hpp>
BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) \
/**/
-# define AUX778076_CONVERT_CN_TO(z,n,TARGET) \
- TARGET(BOOST_PP_CAT(C,n)) \
- /**/
-
+# if !defined(AUX778076_SEQUENCE_CONVERT_CN_TO)
+# define AUX778076_SEQUENCE_CONVERT_CN_TO(z,n,TARGET) BOOST_PP_CAT(C,n)
+# endif
+
# define AUX778076_SEQUENCE_N_ARGS(n) \
T BOOST_PP_COMMA_IF(n) \
- BOOST_PP_ENUM(n,AUX778076_CONVERT_CN_TO,T) \
+ BOOST_PP_ENUM(n,AUX778076_SEQUENCE_CONVERT_CN_TO,T) \
/**/
# define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) \
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# undef AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS
-# undef AUX778076_CONVERT_CN_TO
# undef AUX778076_SEQUENCE_N_ARGS
+# undef AUX778076_SEQUENCE_CONVERT_CN_TO
# undef AUX778076_SEQUENCE_N_PARAMS
# undef AUX778076_SEQUENCE_DEFAULT_PARAMS
# undef AUX778076_SEQUENCE_ARGS
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: shift_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: single_element_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/advance_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: sort_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/partition.hpp>
#include <boost/mpl/copy.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: static_cast.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 08:24:50 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24957 $
+// $Id: template_arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/ttp.hpp>
#include <boost/mpl/aux_/config/lambda.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: template_arity_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-02-28 17:56:33 -0500 (Tue, 28 Feb 2006) $
-// $Revision: 33181 $
+// $Id: test.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/test/test_case.hpp>
#include <boost/mpl/aux_/test/data.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-01 12:32:41 -0400 (Fri, 01 Oct 2004) $
-// $Revision: 25513 $
+// $Id: assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/assert.hpp>
#include <boost/preprocessor/cat.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: data.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/noncopyable.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: test_case.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/cat.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: traits_lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/sequence_tag_fwd.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 08:07:57 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24956 $
+// $Id: transform_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/apply.hpp>
#include <boost/mpl/iterator_tags.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: type_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: unwrap.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/ref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-20 12:52:43 -0500 (Mon, 20 Dec 2004) $
-// $Revision: 26558 $
+// $Id: value_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/static_cast.hpp>
#include <boost/mpl/aux_/config/integral.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
-// $Revision: 30670 $
+// $Id: yes_no.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/nttp_decl.hpp>
#include <boost/mpl/aux_/config/arrays.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/back_fwd.hpp>
#include <boost/mpl/aux_/back_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: back_inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/inserter.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: begin.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/aux_/begin_end_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: begin_end_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-26 10:51:08 -0400 (Tue, 26 Oct 2004) $
-// $Revision: 25875 $
+// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/bind_fwd.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
# define i_ BOOST_PP_FRAME_ITERATION(1)
# endif
# undef j_
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bind_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bitand.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME bitand_
#define AUX778076_OP_PREFIX bitand
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bitor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME bitor_
#define AUX778076_OP_PREFIX bitor
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bitwise.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/bitand.hpp>
#include <boost/mpl/bitor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bitxor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME bitxor_
#define AUX778076_OP_PREFIX bitxor
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-26 05:54:25 -0400 (Sun, 26 Sep 2004) $
-// $Revision: 25411 $
+// $Id: bool.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/bool_fwd.hpp>
#include <boost/mpl/integral_c_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: bool_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/aux_/clear_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: comparison.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/not_equal_to.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: contains.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: contains_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: copy.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: copy_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: count.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/count_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: count_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: count_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/next.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: deque.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/vector.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: deref.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/msvc_type.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-01-25 20:58:33 -0500 (Tue, 25 Jan 2005) $
-// $Revision: 26850 $
+// $Id: distance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/distance_fwd.hpp>
#include <boost/mpl/iter_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: distance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/common_name_wknd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: divides.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME divides
#define AUX778076_OP_TOKEN /
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty_base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: empty_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/iter_fold_if_impl.hpp>
#include <boost/mpl/aux_/iter_apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: equal_to.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME equal_to
#define AUX778076_OP_TOKEN ==
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: erase.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: erase_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: erase_key.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_key_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: erase_key_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: eval_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/if.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: filter_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/lambda.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: find.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/same_as.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: find_if.hpp 49274 2008-10-11 07:22:05Z agurtovoy $
+// $Date: 2008-10-11 03:22:05 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49274 $
#include <boost/mpl/aux_/find_if_pred.hpp>
#include <boost/mpl/arg.hpp>
typedef typename iter_fold_if<
Sequence
, void
- , arg<1> // ignore
+ , mpl::arg<1> // ignore
, protect< aux::find_if_pred<Predicate> >
>::type result_;
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: for_each.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/aux_/front_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: front_inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/inserter.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: greater.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME greater
#define AUX778076_OP_TOKEN >
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: greater_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME greater_equal
#define AUX778076_OP_TOKEN >=
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_key.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_key_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: has_key_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: has_xxx.hpp 49273 2008-10-11 06:54:06Z agurtovoy $
+// $Date: 2008-10-11 02:54:06 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49273 $
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/type_wrapper.hpp>
// applied to partial specialization to fix some apparently random failures
// (thanks to Daniel Wallin for researching this!)
-namespace boost { namespace mpl { namespace aux {
-template< typename T > struct msvc71_sfinae_helper { typedef void type; };
-}}}
-
# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
+template< typename T > \
+struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \
+{ \
+ typedef void type; \
+};\
+\
template< typename T, typename U = void > \
struct BOOST_PP_CAT(trait,_impl_) \
{ \
template< typename T > \
struct BOOST_PP_CAT(trait,_impl_)< \
T \
- , typename boost::mpl::aux::msvc71_sfinae_helper< typename T::name >::type \
+ , typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \
> \
{ \
BOOST_STATIC_CONSTANT(bool, value = true); \
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: identity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/value_wknd.hpp>
#include <boost/mpl/aux_/static_cast.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: index_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/find_if_pred.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: index_of.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/index_if.hpp>
#include <boost/mpl/same_as.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: inherit.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/empty_base.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: inherit_linearly.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/empty_base.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/insert_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/insert_range_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert_range_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/int_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: int_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 16:44:30 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35926 $
+// $Id: integral_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/integral_c_fwd.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 16:44:30 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35926 $
+// $Id: integral_c_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/workaround.hpp>
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: integral_c_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 04:53:22 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24947 $
+// $Id: is_placeholder.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/arg_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
-// $Revision: 30670 $
+// $Id: is_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/not.hpp>
#include <boost/mpl/and.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iter_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iter_fold_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/logical.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iterator_category.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: iterator_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: iterator_tags.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-02 15:08:57 -0400 (Sat, 02 Oct 2004) $
-// $Revision: 25528 $
+// $Id: joint_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/joint_iter.hpp>
#include <boost/mpl/plus.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-14 17:34:44 -0500 (Tue, 14 Dec 2004) $
-// $Revision: 26508 $
+// $Id: key_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/key_type_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: key_type_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/lambda_fwd.hpp>
#include <boost/mpl/bind.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: lambda_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/void_fwd.hpp>
#include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: less.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME less
#define AUX778076_OP_TOKEN <
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: less_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME less_equal
#define AUX778076_OP_TOKEN <=
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
# define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_LIMIT_LIST_SIZE)
# define BOOST_MPL_LIMIT_LIST_SIZE 20
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_LIMIT_MAP_SIZE)
# define BOOST_MPL_LIMIT_MAP_SIZE 20
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_LIMIT_SET_SIZE)
# define BOOST_MPL_LIMIT_SET_SIZE 20
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: unrolling.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_LIMIT_UNROLLING)
# define BOOST_MPL_LIMIT_UNROLLING 4
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_LIMIT_VECTOR_SIZE)
# define BOOST_MPL_LIMIT_VECTOR_SIZE 20
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: list.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/list.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/list/aux_/iterator.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/list/aux_/item.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/not.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 20:44:00 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35938 $
+// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-01 12:32:41 -0400 (Fri, 01 Oct 2004) $
-// $Revision: 25513 $
+// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if defined(BOOST_PP_IS_ITERATING)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if defined(BOOST_PP_IS_ITERATING)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-24 04:18:08 -0400 (Sun, 24 Oct 2004) $
-// $Revision: 25850 $
+// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/next.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-28 02:18:24 -0500 (Sun, 28 Nov 2004) $
-// $Revision: 26337 $
+// $Id: list0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/list/list0.hpp>
#include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list0_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list10.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list10_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list20.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list20_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list30.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list30_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list40.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: list50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list40_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: list_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/list.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: logical.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: long.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-28 09:56:59 -0400 (Tue, 28 Sep 2004) $
-// $Revision: 25453 $
+// $Id: long_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: lower_bound.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/less.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# define BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL
#endif
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/map.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-12-05 12:59:21 -0500 (Mon, 05 Dec 2005) $
-// $Revision: 31919 $
+// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/long.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/map/aux_/map0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: contains_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/if.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/not.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_fwd.hpp>
#include <boost/mpl/map/aux_/erase_key_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_key_fwd.hpp>
#include <boost/mpl/map/aux_/has_key_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/has_key_fwd.hpp>
#include <boost/mpl/map/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 20:44:00 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35938 $
+// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-14 09:05:33 -0500 (Tue, 14 Dec 2004) $
-// $Revision: 26498 $
+// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/insert_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-14 09:05:33 -0500 (Tue, 14 Dec 2004) $
-// $Revision: 26498 $
+// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/void.hpp>
#include <boost/mpl/pair.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-14 09:05:33 -0500 (Tue, 14 Dec 2004) $
-// $Revision: 26498 $
+// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/map/aux_/map0.hpp>
#include <boost/mpl/map/aux_/at_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: key_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/key_type_fwd.hpp>
#include <boost/mpl/pair.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-13 14:25:11 -0400 (Wed, 13 Oct 2004) $
-// $Revision: 25712 $
+// $Id: map0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-14 09:05:33 -0500 (Tue, 14 Dec 2004) $
-// $Revision: 26498 $
+// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#else
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/map/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: value_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/value_type_fwd.hpp>
#include <boost/mpl/pair.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/map/aux_/contains_impl.hpp>
#include <boost/mpl/map/aux_/at_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-05 05:45:19 -0400 (Sun, 05 Sep 2004) $
-// $Revision: 24912 $
+// $Id: map10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/map/map0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/map/map10.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/map/map20.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/map/map30.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: map50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/map/map40.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: fixed_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/static_constant.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: is_even.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: rational_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/static_constant.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: max.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/min_max.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: max_element.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/less.hpp>
#include <boost/mpl/iter_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: min.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/min_max.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: min_element.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/max_element.hpp>
#include <boost/mpl/not.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: min_max.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/less.hpp>
#include <boost/mpl/if.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: minus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME minus
#define AUX778076_OP_TOKEN -
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: modulus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME modulus
#define AUX778076_OP_TOKEN %
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: multiplies.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/times.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: count_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/multiset/aux_/tag.hpp>
#include <boost/mpl/count_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/multiset/aux_/item.hpp>
#include <boost/mpl/multiset/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/multiset/aux_/tag.hpp>
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: multiset0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/multiset/aux_/tag.hpp>
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: multiset0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
//#include <boost/mpl/multiset/aux_/at.hpp>
//#include <boost/mpl/multiset/aux_/front.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 05:06:10 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24948 $
+// $Id: negate.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/msvc_eti_base.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: next.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-17 02:09:38 -0400 (Fri, 17 Sep 2004) $
-// $Revision: 25163 $
+// $Id: next_prior.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/common_name_wknd.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: not.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: not_equal_to.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME not_equal_to
#define AUX778076_OP_TOKEN !=
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-06-26 13:18:33 -0400 (Sun, 26 Jun 2005) $
-// $Revision: 29796 $
+// $Id: numeric_cast.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: or.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: order.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/order_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: order_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-14 09:05:33 -0500 (Tue, 14 Dec 2004) $
-// $Revision: 26498 $
+// $Id: pair.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/msvc_eti_base.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: pair_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/iterator_category.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: partition.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/stable_partition.hpp>
#include <boost/mpl/aux_/inserter_algorithm.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-16 10:09:12 -0400 (Thu, 16 Sep 2004) $
-// $Revision: 25148 $
+// $Id: placeholders.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: plus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME plus
#define AUX778076_OP_TOKEN +
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_back_fwd.hpp>
#include <boost/mpl/aux_/pop_back_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/aux_/pop_front_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: print.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/identity.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: prior.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-07 17:37:24 -0400 (Tue, 07 Sep 2004) $
-// $Revision: 24963 $
+// $Id: protect.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/arity.hpp>
#include <boost/mpl/aux_/config/dtp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/aux_/push_back_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/aux_/push_front_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
#ifndef BOOST_MPL_QUOTE_HPP_INCLUDED
#define BOOST_MPL_QUOTE_HPP_INCLUDED
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-05-02 23:27:58 -0400 (Tue, 02 May 2006) $
-// $Revision: 33913 $
+// $Id: quote.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
+// $Date: 2008-10-11 02:50:46 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49272 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/void.hpp>
# include <boost/mpl/aux_/has_type.hpp>
#endif
+#include <boost/mpl/aux_/config/bcc.hpp>
#include <boost/mpl/aux_/config/ttp.hpp>
-#if defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS)
+#if defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+ && !defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS)
# define BOOST_MPL_CFG_NO_QUOTE_TEMPLATE
#endif
struct BOOST_PP_CAT(quote,i_)
{
template< BOOST_MPL_PP_PARAMS(i_, typename U) > struct apply
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS)
+ {
+ typedef typename quote_impl<
+ F< BOOST_MPL_PP_PARAMS(i_, U) >
+ , aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value
+ >::type type;
+ };
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
: quote_impl<
F< BOOST_MPL_PP_PARAMS(i_, U) >
, aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value
>
+ {
+ };
#else
: quote_impl< aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value >
::template result_< F< BOOST_MPL_PP_PARAMS(i_, U) > >
-#endif
{
};
+#endif
};
#undef i_
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: range_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/range_c/front.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: remove.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/remove_if.hpp>
#include <boost/mpl/same_as.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: remove_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: replace.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/replace_if.hpp>
#include <boost/mpl/same_as.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: replace_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/transform.hpp>
#include <boost/mpl/apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: reverse.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/copy.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: reverse_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: reverse_iter_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: same_as.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/not.hpp>
#include <boost/mpl/aux_/lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: sequence_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/sequence_tag_fwd.hpp>
#include <boost/mpl/aux_/has_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: sequence_tag_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/set.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/set/aux_/has_key_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/set/aux_/iterator.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/set/aux_/set0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/not.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_fwd.hpp>
#include <boost/mpl/set/aux_/erase_key_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/erase_key_fwd.hpp>
#include <boost/mpl/set/aux_/has_key_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-10-13 14:25:11 -0400 (Wed, 13 Oct 2004) $
-// $Revision: 25712 $
+// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/set/aux_/tag.hpp>
#include <boost/mpl/has_key_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 20:44:00 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35938 $
+// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/preprocessor.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/insert_fwd.hpp>
#include <boost/mpl/set/aux_/has_key_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/set/aux_/set0.hpp>
#include <boost/mpl/has_key.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: key_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/key_type_fwd.hpp>
#include <boost/mpl/set/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-06-18 18:03:09 -0400 (Sat, 18 Jun 2005) $
-// $Revision: 29681 $
+// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/dec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2007-11-25 13:07:19 -0500 (Sun, 25 Nov 2007) $
-// $Revision: 41369 $
+// $Id: set0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/set/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: value_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/value_type_fwd.hpp>
#include <boost/mpl/set/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/set/aux_/at_impl.hpp>
#include <boost/mpl/set/aux_/clear_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/set/set0.hpp>
#include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set0_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set10.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set10_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set20.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set20_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set30.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set30_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: set50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set40.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set40_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: set_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/set.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: shift_left.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME shift_left
#define AUX778076_OP_TOKEN <<
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: shift_right.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME shift_right
#define AUX778076_OP_TOKEN >>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: single_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/single_element_iter.hpp>
#include <boost/mpl/iterator_range.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size_t.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_t_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size_t_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/config.hpp> // make sure 'size_t' is placed into 'std'
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: sizeof.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_t.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: sort.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/sort_impl.hpp>
#include <boost/mpl/aux_/inserter_algorithm.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: stable_partition.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: switch.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: times.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#define AUX778076_OP_NAME times
#define AUX778076_OP_TOKEN *
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-20 12:18:17 -0500 (Mon, 20 Dec 2004) $
-// $Revision: 26557 $
+// $Id: transform.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: transform_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/lambda.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: unique.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: unpack_args.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/apply.hpp>
///// iteration, depth == 1
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
# define i_ BOOST_PP_FRAME_ITERATION(1)
# undef i_
+#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: upper_bound.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/less.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
# define BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL
#endif
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: value_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/value_type_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-03-22 17:45:55 -0400 (Sat, 22 Mar 2008) $
-// $Revision: 43798 $
+// $Id: value_type_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: vector.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/vector.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-03 21:33:47 -0400 (Fri, 03 Sep 2004) $
-// $Revision: 24897 $
+// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/minus.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-12-20 14:35:33 -0500 (Mon, 20 Dec 2004) $
-// $Revision: 26560 $
+// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/back_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/vector/aux_/vector0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/vector/aux_/at.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2006-11-08 20:21:03 -0500 (Wed, 08 Nov 2006) $
-// $Revision: 35937 $
+// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2005-05-14 20:39:04 -0400 (Sat, 14 May 2005) $
-// $Revision: 28913 $
+// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/iterator_tags.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_shifted_params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_shifted_params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_back_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/vector/aux_/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/vector/aux_/front.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: vector0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/vector/vector0.hpp>
#include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector0_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector10.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector10_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector20.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector20_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector30.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector30_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector40.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: vector50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector40_c.hpp>
#ifndef BOOST_MPL_VECTOR_C_HPP_INCLUDED
#define BOOST_MPL_VECTOR_C_HPP_INCLUDED
-// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Aleksey Gurtovoy 2000-2008
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-11-27 20:58:27 -0500 (Sat, 27 Nov 2004) $
-// $Revision: 26325 $
+// $Id: vector_c.hpp 49271 2008-10-11 06:46:00Z agurtovoy $
+// $Date: 2008-10-11 02:46:00 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49271 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/vector.hpp>
# define AUX778076_SEQUENCE_NAME vector_c
# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE
# define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(vector,n),_c)
+# define AUX778076_SEQUENCE_CONVERT_CN_TO(z,n,TARGET) TARGET(BOOST_PP_CAT(C,n))
# define AUX778076_SEQUENCE_INTEGRAL_WRAPPER
# include <boost/mpl/aux_/sequence_wrapper.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: void.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/void_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Id: void_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Source$
-// $Date: 2008-07-21 04:00:06 -0400 (Mon, 21 Jul 2008) $
-// $Revision: 47650 $
+// $Id: zip_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
#include <boost/mpl/transform.hpp>
#include <boost/mpl/begin_end.hpp>
// in all copies. This software is provided "as is" without express or
// implied warranty, and with no claim as to its suitability for any purpose.
+// boostinspect:nolicense (don't complain about the lack of a Boost license)
+// (Paul Moore hasn't been in contact for years, so there's no way to change the
+// license.)
+
// See http://www.boost.org/libs/rational for documentation.
// Credits:
#define BOOST_RATIONAL_HPP
#include <iostream> // for std::istream and std::ostream
-#include <iomanip> // for std::noskipws
+#include <ios> // for std::noskipws
#include <stdexcept> // for std::domain_error
#include <string> // for std::string implicit constructor
#include <boost/operators.hpp> // for boost::addable etc
}
else
{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4800)
+#endif
// Exactly one of the remainders is zero, so all following c.f.
// components of that variable are infinity, while the other variable
// has a finite next c.f. component. So that other variable has the
// lesser value (modulo the reversal flag!).
return ( ts.r != zero ) != static_cast<bool>( reverse );
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
}
}
# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
+{
+ return r.get_pointer();
+}
+
} // namespace boost
#endif // #ifndef BOOST_REF_HPP_INCLUDED
inline int (wcscoll)(const wchar_t *p1, const wchar_t *p2)
{ return wcscoll(p1,p2); }
#undef wcscoll
-#elif defined(BOOST_NO_STDC_NAMESPACE)
+#elif defined(BOOST_NO_STDC_NAMESPACE) && !defined(UNDER_CE)
using ::wcscoll;
#endif
unsigned int m_can_be_null; // whether we can match a null string
re_detail::raw_storage m_data; // the buffer in which our states are constructed
typename traits::char_class_type m_word_mask; // mask used to determine if a character is a word character
+ std::vector<
+ std::pair<
+ std::size_t, std::size_t> > m_subs; // Position of sub-expressions within the *string*.
};
//
// class basic_regex_implementation
{
return this->m_expression;
}
+ std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const
+ {
+ if(n == 0)
+ throw std::out_of_range("0 is not a valid subexpression index.");
+ const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n - 1);
+ std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second);
+ return p;
+ }
//
// begin, end:
const_iterator BOOST_REGEX_CALL begin()const
{
public:
// typedefs:
- typedef typename traits::size_type traits_size_type;
+ typedef std::size_t traits_size_type;
typedef typename traits::string_type traits_string_type;
typedef charT char_type;
typedef traits traits_type;
return m_pimpl.get() ? m_pimpl->str() : std::basic_string<charT>();
}
//
- // begin, end:
+ // begin, end, subexpression:
+ std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const
+ {
+ if(!m_pimpl.get())
+ throw std::logic_error("Can't access subexpressions in an invalid regex.");
+ return m_pimpl->subexpression(n);
+ }
const_iterator BOOST_REGEX_CALL begin()const
{
return (m_pimpl.get() ? m_pimpl->begin() : 0);
m_traits; // convenience reference to traits class
re_syntax_base* m_last_state; // the last state we added
bool m_icase; // true for case insensitive matches
- unsigned m_repeater_id; // the id of the next repeater
+ unsigned m_repeater_id; // the state_id of the next repeater
bool m_has_backrefs; // true if there are actually any backrefs
unsigned m_backrefs; // bitmask of permitted backrefs
boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for;
case syntax_element_char_rep:
case syntax_element_short_set_rep:
case syntax_element_long_set_rep:
- // set the id of this repeat:
- static_cast<re_repeat*>(state)->id = m_repeater_id++;
+ // set the state_id of this repeat:
+ static_cast<re_repeat*>(state)->state_id = m_repeater_id++;
// fall through:
case syntax_element_alt:
std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));
case syntax_element_short_set_rep:
case syntax_element_long_set_rep:
{
- unsigned id = static_cast<re_repeat*>(pt)->id;
- if(id > sizeof(m_bad_repeats) * CHAR_BIT)
+ unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
+ if(state_id > sizeof(m_bad_repeats) * CHAR_BIT)
return true; // run out of bits, assume we can't traverse this one.
static const boost::uintmax_t one = 1uL;
- return m_bad_repeats & (one << id);
+ return m_bad_repeats & (one << state_id);
}
default:
return false;
case syntax_element_short_set_rep:
case syntax_element_long_set_rep:
{
- unsigned id = static_cast<re_repeat*>(pt)->id;
+ unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
static const boost::uintmax_t one = 1uL;
- if(id <= sizeof(m_bad_repeats) * CHAR_BIT)
- m_bad_repeats |= (one << id);
+ if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)
+ m_bad_repeats |= (one << state_id);
}
default:
break;
m_position = m_base = p1;
m_end = p2;
// empty strings are errors:
- if(p1 == p2)
+ if((p1 == p2) &&
+ (
+ ((l_flags & regbase::main_option_type) != regbase::perl_syntax_group)
+ || (l_flags & regbase::no_empty_expressions)
+ )
+ )
{
fail(regex_constants::error_empty, 0);
return;
//
unsigned markid = 0;
if(0 == (this->flags() & regbase::nosubs))
+ {
markid = ++m_mark_count;
+ if(this->flags() & regbase::save_subexpression_location)
+ this->m_pdata->m_subs.push_back(std::pair<std::size_t, std::size_t>(std::distance(m_base, m_position) - 1, 0));
+ }
re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));
pb->index = markid;
std::ptrdiff_t last_paren_start = this->getoffset(pb);
return false;
}
BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
+ if(markid && (this->flags() & regbase::save_subexpression_location))
+ this->m_pdata->m_subs.at(markid - 1).second = std::distance(m_base, m_position);
++m_position;
//
// append closing parenthesis state:
// error check: if there have been no previous states,
// or if the last state was a '(' then error:
//
- if((this->m_last_state == 0) || (this->m_last_state->type == syntax_element_startmark))
+ if(
+ ((this->m_last_state == 0) || (this->m_last_state->type == syntax_element_startmark))
+ &&
+ !(
+ ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group)
+ &&
+ ((this->flags() & regbase::no_empty_expressions) == 0)
+ )
+ )
{
fail(regex_constants::error_empty, this->m_position - this->m_base);
return false;
// alternative then that's an error:
//
if((this->m_alt_insert_point == static_cast<std::ptrdiff_t>(this->m_pdata->m_data.size()))
- && m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start))
+ && m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start)
+ &&
+ !(
+ ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group)
+ &&
+ ((this->flags() & regbase::no_empty_expressions) == 0)
+ )
+ )
{
fail(regex_constants::error_empty, this->m_position - this->m_base);
return false;
if(pos != m_custom_class_names.end())
return pos->second;
}
- std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
- BOOST_ASSERT(id < sizeof(masks) / sizeof(masks[0]));
- return masks[id];
+ std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
+ BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
+ return masks[state_id];
}
#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET
#if defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
inline bool can_start(wchar_t c, const unsigned char* map, unsigned char mask)
{
- return ((c >= (1 << CHAR_BIT)) ? true : map[c] & mask);
+ return ((c >= static_cast<wchar_t>(1u << CHAR_BIT)) ? true : map[c] & mask);
}
#endif
#endif
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+inline bool can_start(unsigned int c, const unsigned char* map, unsigned char mask)
+{
+ return (((c >= static_cast<unsigned int>(1u << CHAR_BIT)) ? true : map[c] & mask));
+}
+#endif
//
{
repeater_count** stack;
repeater_count* next;
- int id;
+ int state_id;
std::size_t count; // the number of iterations so far
BidiIterator start_pos; // where the last repeat started
public:
{
stack = s;
next = 0;
- id = -1;
+ state_id = -1;
count = 0;
}
repeater_count(int i, repeater_count** s, BidiIterator start)
: start_pos(start)
{
- id = i;
+ state_id = i;
stack = s;
next = *stack;
*stack = this;
- if(id > next->id)
+ if(state_id > next->state_id)
count = 0;
else
{
repeater_count* p = next;
- while(p->id != id)
+ while(p->state_id != state_id)
p = p->next;
count = p->count;
start_pos = p->start_pos;
*stack = next;
}
std::size_t get_count() { return count; }
- int get_id() { return id; }
+ int get_id() { return state_id; }
std::size_t operator++() { return ++count; }
bool check_null_repeat(const BidiIterator& pos, std::size_t max)
{
typedef typename traits::char_type char_type;
typedef perl_matcher<BidiIterator, Allocator, traits> self_type;
typedef bool (self_type::*matcher_proc_type)(void);
- typedef typename traits::size_type traits_size_type;
+ typedef std::size_t traits_size_type;
typedef typename is_byte<char_type>::width_type width_type;
typedef typename regex_iterator_traits<BidiIterator>::difference_type difference_type;
void push_assertion(const re_syntax_base* ps, bool positive);
void push_alt(const re_syntax_base* ps);
void push_repeater_count(int i, repeater_count<BidiIterator>** s);
- void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id);
+ void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id);
void push_non_greedy_repeat(const re_syntax_base* ps);
struct saved_state
{
union{
- unsigned int id;
+ unsigned int state_id;
// this padding ensures correct alignment on 64-bit platforms:
std::size_t padding1;
std::ptrdiff_t padding2;
void* padding3;
};
- saved_state(unsigned i) : id(i) {}
+ saved_state(unsigned i) : state_id(i) {}
};
template <class BidiIterator>
}
template <class BidiIterator, class Allocator, class traits>
-inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id)
+inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id)
{
saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
--pmp;
pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
--pmp;
}
- (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, id);
+ (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, state_id);
m_backup_state = pmp;
}
take_second = can_start(*position, rep->_map, (unsigned char)mask_skip);
}
- if(take_first || (next_count->get_id() != rep->id))
+ if((m_backup_state->state_id != saved_state_repeater_count)
+ || (static_cast<saved_repeater<BidiIterator>*>(m_backup_state)->count.get_id() != rep->state_id)
+ || (next_count->get_id() != rep->state_id))
{
// we're moving to a different repeat from the last
// one, so set up a counter object:
- push_repeater_count(rep->id, &next_count);
+ push_repeater_count(rep->state_id, &next_count);
}
//
// If we've had at least one repeat already, and the last one
//
do
{
- unwinder = s_unwind_table[m_backup_state->id];
+ unwinder = s_unwind_table[m_backup_state->state_id];
cont = (this->*unwinder)(m_recursive_result);
}while(cont);
//
// Always copy the repeat count, so that the state is restored
// when we exit this scope:
//
- repeater_count<BidiIterator> r(rep->id, &next_count, position);
+ repeater_count<BidiIterator> r(rep->state_id, &next_count, position);
//
// If we've had at least one repeat already, and the last one
// matched the NULL string then set the repeat count to
nocollate = 0, // don't use locale specific collation (deprecated)
collate = 1 << 21, // use locale specific collation
nosubs = 1 << 22, // don't mark sub-expressions
+ save_subexpression_location = 1 << 23, // save subexpression locations
+ no_empty_expressions = 1 << 24, // no empty expressions allowed
optimize = 0, // not really supported
mod_x = ::boost::regbase::mod_x,
mod_s = ::boost::regbase::mod_s,
no_mod_s = ::boost::regbase::no_mod_s,
+ save_subexpression_location = ::boost::regbase::save_subexpression_location,
+ no_empty_expressions = ::boost::regbase::no_empty_expressions,
basic = ::boost::regbase::basic,
extended = ::boost::regbase::extended,
//
// OK find out what kind it is:
//
+ bool have_brace = false;
+ const char_type* save_position = m_position;
switch(*m_position)
{
case '&':
case '$':
put(*m_position++);
break;
+ case '{':
+ have_brace = true;
+ ++m_position;
+ // fall through....
default:
// see if we have a number:
{
std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
int v = m_traits.toi(m_position, m_position + len, 10);
- if(v < 0)
+ if((v < 0) || (have_brace && ((m_position == m_end) || (*m_position != '}'))))
{
// leave the $ as is, and carry on:
- --m_position;
+ m_position = --save_position;
put(*m_position);
++m_position;
break;
}
// otherwise output sub v:
put(this->m_results[v]);
+ if(have_brace)
+ ++m_position;
}
}
}
BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name);
//
-// get the id of a character clasification, the individual
-// traits classes then transform that id into a bitmask:
+// get the state_id of a character clasification, the individual
+// traits classes then transform that state_id into a bitmask:
//
template <class charT>
struct character_pointer_range
struct re_repeat : public re_alt
{
std::size_t min, max; // min and max allowable repeats
- int id; // Unique identifier for this repeat
+ int state_id; // Unique identifier for this repeat
bool leading; // True if this repeat is at the start of the machine (lets us optimize some searches)
bool greedy; // True if this is a greedy repeat
};
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(wchar_t, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type id);
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type state_id);
#endif
#endif
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(char, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(wchar_t, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type id);
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type state_id);
#endif
#endif
BOOST_REGEX_DECL cat_type BOOST_REGEX_CALL w32_cat_open(const std::string& name);
-BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type id, int i, const std::string& def);
+BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type state_id, int i, const std::string& def);
#ifndef BOOST_NO_WREGEX
-BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type id, int i, const std::wstring& def);
+BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type state_id, int i, const std::wstring& def);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::basic_string<unsigned short>& def);
#endif
#endif
-BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type id, const char* p1, const char* p2);
+BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type state_id, const char* p1, const char* p2);
#ifndef BOOST_NO_WREGEX
-BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type id, const wchar_t* p1, const wchar_t* p2);
+BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type state_id, const wchar_t* p1, const wchar_t* p2);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type id, const unsigned short* p1, const unsigned short* p2);
+BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type state_id, const unsigned short* p1, const unsigned short* p2);
#endif
#endif
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_tolower(char c, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_tolower(wchar_t c, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type id);
+BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type state_id);
#endif
#endif
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_toupper(char c, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type, boost::uint32_t mask, wchar_t c);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type id, boost::uint32_t m, unsigned short c);
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type state_id, boost::uint32_t m, unsigned short c);
#endif
#endif
//
if(pos != m_custom_class_names.end())
return pos->second;
}
- std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
- if(id < sizeof(masks) / sizeof(masks[0]))
- return masks[id];
+ std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
+ if(state_id < sizeof(masks) / sizeof(masks[0]))
+ return masks[state_id];
return masks[0];
}
// http://www.boost.org/libs/smart_ptr/scoped_array.htm
//
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/config.hpp> // in case ptrdiff_t not in std
-
-#include <boost/detail/workaround.hpp>
-
-#include <cstddef> // for std::ptrdiff_t
-
-namespace boost
-{
-
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_array_constructor_hook(void * p);
-void sp_array_destructor_hook(void * p);
-
-#endif
-
-// scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
-// is guaranteed, either on destruction of the scoped_array or via an explicit
-// reset(). Use shared_array or std::vector if your needs are more complex.
-
-template<class T> class scoped_array // noncopyable
-{
-private:
-
- T * ptr;
-
- scoped_array(scoped_array const &);
- scoped_array & operator=(scoped_array const &);
-
- typedef scoped_array<T> this_type;
-
- void operator==( scoped_array const& ) const;
- void operator!=( scoped_array const& ) const;
-
-public:
-
- typedef T element_type;
-
- explicit scoped_array(T * p = 0) : ptr(p) // never throws
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_array_constructor_hook(ptr);
-#endif
- }
-
- ~scoped_array() // never throws
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_array_destructor_hook(ptr);
-#endif
- boost::checked_array_delete(ptr);
- }
-
- void reset(T * p = 0) // never throws
- {
- BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
- this_type(p).swap(*this);
- }
-
- T & operator[](std::ptrdiff_t i) const // never throws
- {
- BOOST_ASSERT(ptr != 0);
- BOOST_ASSERT(i >= 0);
- return ptr[i];
- }
-
- T * get() const // never throws
- {
- return ptr;
- }
-
- // implicit conversion to "bool"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
- operator bool () const
- {
- return ptr != 0;
- }
-
-#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
- typedef T * (this_type::*unspecified_bool_type)() const;
-
- operator unspecified_bool_type() const // never throws
- {
- return ptr == 0? 0: &this_type::get;
- }
-
-#else
-
- typedef T * this_type::*unspecified_bool_type;
-
- operator unspecified_bool_type() const // never throws
- {
- return ptr == 0? 0: &this_type::ptr;
- }
-
-#endif
-
- bool operator! () const // never throws
- {
- return ptr == 0;
- }
-
- void swap(scoped_array & b) // never throws
- {
- T * tmp = b.ptr;
- b.ptr = ptr;
- ptr = tmp;
- }
-
-};
-
-template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
-{
- a.swap(b);
-}
-
-} // namespace boost
+#include <boost/smart_ptr/scoped_array.hpp>
#endif // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
// http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
//
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/detail/workaround.hpp>
-
-#ifndef BOOST_NO_AUTO_PTR
-# include <memory> // for std::auto_ptr
-#endif
-
-namespace boost
-{
-
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook(void * p);
-void sp_scalar_destructor_hook(void * p);
-
-#endif
-
-// scoped_ptr mimics a built-in pointer except that it guarantees deletion
-// of the object pointed to, either on destruction of the scoped_ptr or via
-// an explicit reset(). scoped_ptr is a simple solution for simple needs;
-// use shared_ptr or std::auto_ptr if your needs are more complex.
-
-template<class T> class scoped_ptr // noncopyable
-{
-private:
-
- T * ptr;
-
- scoped_ptr(scoped_ptr const &);
- scoped_ptr & operator=(scoped_ptr const &);
-
- typedef scoped_ptr<T> this_type;
-
- void operator==( scoped_ptr const& ) const;
- void operator!=( scoped_ptr const& ) const;
-
-public:
-
- typedef T element_type;
-
- explicit scoped_ptr(T * p = 0): ptr(p) // never throws
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_scalar_constructor_hook(ptr);
-#endif
- }
-
-#ifndef BOOST_NO_AUTO_PTR
-
- explicit scoped_ptr(std::auto_ptr<T> p): ptr(p.release()) // never throws
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_scalar_constructor_hook(ptr);
-#endif
- }
-
-#endif
-
- ~scoped_ptr() // never throws
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_scalar_destructor_hook(ptr);
-#endif
- boost::checked_delete(ptr);
- }
-
- void reset(T * p = 0) // never throws
- {
- BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
- this_type(p).swap(*this);
- }
-
- T & operator*() const // never throws
- {
- BOOST_ASSERT(ptr != 0);
- return *ptr;
- }
-
- T * operator->() const // never throws
- {
- BOOST_ASSERT(ptr != 0);
- return ptr;
- }
-
- T * get() const // never throws
- {
- return ptr;
- }
-
- // implicit conversion to "bool"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
- operator bool () const
- {
- return ptr != 0;
- }
-
-#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
- typedef T * (this_type::*unspecified_bool_type)() const;
-
- operator unspecified_bool_type() const // never throws
- {
- return ptr == 0? 0: &this_type::get;
- }
-
-#else
- typedef T * this_type::*unspecified_bool_type;
-
- operator unspecified_bool_type() const // never throws
- {
- return ptr == 0? 0: &this_type::ptr;
- }
-
-#endif
-
- bool operator! () const // never throws
- {
- return ptr == 0;
- }
-
- void swap(scoped_ptr & b) // never throws
- {
- T * tmp = b.ptr;
- b.ptr = ptr;
- ptr = tmp;
- }
-};
-
-template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
-{
- a.swap(b);
-}
-
-// get_pointer(p) is a generic way to say p.get()
-
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
-{
- return p.get();
-}
-
-} // namespace boost
+#include <boost/smart_ptr/scoped_ptr.hpp>
#endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
// See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
//
-#include <boost/config.hpp> // for broken compiler workarounds
-
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/detail/shared_array_nmt.hpp>
-#else
-
-#include <memory> // TR1 cyclic inclusion fix
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-
-#include <boost/detail/shared_count.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <cstddef> // for std::ptrdiff_t
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-
-namespace boost
-{
-
-//
-// shared_array
-//
-// shared_array extends shared_ptr to arrays.
-// The array pointed to is deleted when the last shared_array pointing to it
-// is destroyed or reset.
-//
-
-template<class T> class shared_array
-{
-private:
-
- // Borland 5.5.1 specific workarounds
- typedef checked_array_deleter<T> deleter;
- typedef shared_array<T> this_type;
-
-public:
-
- typedef T element_type;
-
- explicit shared_array(T * p = 0): px(p), pn(p, deleter())
- {
- }
-
- //
- // Requirements: D's copy constructor must not throw
- //
- // shared_array will release p by calling d(p)
- //
-
- template<class D> shared_array(T * p, D d): px(p), pn(p, d)
- {
- }
-
-// generated copy constructor, assignment, destructor are fine
-
- void reset(T * p = 0)
- {
- BOOST_ASSERT(p == 0 || p != px);
- this_type(p).swap(*this);
- }
-
- template <class D> void reset(T * p, D d)
- {
- this_type(p, d).swap(*this);
- }
-
- T & operator[] (std::ptrdiff_t i) const // never throws
- {
- BOOST_ASSERT(px != 0);
- BOOST_ASSERT(i >= 0);
- return px[i];
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- // implicit conversion to "bool"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
- operator bool () const
- {
- return px != 0;
- }
-
-#elif defined( _MANAGED )
-
- static void unspecified_bool( this_type*** )
- {
- }
-
- typedef void (*unspecified_bool_type)( this_type*** );
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: unspecified_bool;
- }
-
-#elif \
- ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
- ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) )
-
- typedef T * (this_type::*unspecified_bool_type)() const;
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: &this_type::get;
- }
-
-#else
-
- typedef T * this_type::*unspecified_bool_type;
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: &this_type::px;
- }
-
-#endif
-
- bool operator! () const // never throws
- {
- return px == 0;
- }
-
- bool unique() const // never throws
- {
- return pn.unique();
- }
-
- long use_count() const // never throws
- {
- return pn.use_count();
- }
-
- void swap(shared_array<T> & other) // never throws
- {
- std::swap(px, other.px);
- pn.swap(other.pn);
- }
-
-private:
-
- T * px; // contained pointer
- detail::shared_count pn; // reference counter
-
-}; // shared_array
-
-template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
-{
- return a.get() == b.get();
-}
-
-template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
-{
- return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
-{
- return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
-{
- a.swap(b);
-}
-
-} // namespace boost
-
-#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/smart_ptr/shared_array.hpp>
#endif // #ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
//
-#include <boost/config.hpp> // for broken compiler workarounds
-
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/detail/shared_ptr_nmt.hpp>
-#else
-
-// In order to avoid circular dependencies with Boost.TR1
-// we make sure that our include of <memory> doesn't try to
-// pull in the TR1 headers: that's why we use this header
-// rather than including <memory> directly:
-#include <boost/config/no_tr1/memory.hpp> // std::auto_ptr
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/detail/shared_count.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/sp_convertible.hpp>
-
-#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
-#include <boost/detail/spinlock_pool.hpp>
-#include <boost/memory_order.hpp>
-#endif
-
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-#include <typeinfo> // for std::bad_cast
-
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
-#include <iosfwd> // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-
-#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
-namespace boost
-{
-
-template<class T> class weak_ptr;
-template<class T> class enable_shared_from_this;
-
-namespace detail
-{
-
-struct static_cast_tag {};
-struct const_cast_tag {};
-struct dynamic_cast_tag {};
-struct polymorphic_cast_tag {};
-
-template<class T> struct shared_ptr_traits
-{
- typedef T & reference;
-};
-
-template<> struct shared_ptr_traits<void>
-{
- typedef void reference;
-};
-
-#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
-
-template<> struct shared_ptr_traits<void const>
-{
- typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void volatile>
-{
- typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void const volatile>
-{
- typedef void reference;
-};
-
-#endif
-
-// enable_shared_from_this support
-
-template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, boost::enable_shared_from_this<T> const * pe, Y const * px )
-{
- if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
-}
-
-#ifdef _MANAGED
-
-// Avoid C4793, ... causes native code generation
-
-struct sp_any_pointer
-{
- template<class T> sp_any_pointer( T* ) {}
-};
-
-inline void sp_enable_shared_from_this( shared_count const & /*pn*/, sp_any_pointer, sp_any_pointer )
-{
-}
-
-#else // _MANAGED
-
-#ifdef sgi
-// Turn off: the last argument of the varargs function "sp_enable_shared_from_this" is unnamed
-# pragma set woff 3506
-#endif
-
-inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
-{
-}
-
-#ifdef sgi
-# pragma reset woff 3506
-#endif
-
-#endif // _MANAGED
-
-#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_AUTO_PTR )
-
-// rvalue auto_ptr support based on a technique by Dave Abrahams
-
-template< class T, class R > struct sp_enable_if_auto_ptr
-{
-};
-
-template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
-{
- typedef R type;
-};
-
-#endif
-
-} // namespace detail
-
-
-//
-// shared_ptr
-//
-// An enhanced relative of scoped_ptr with reference counted copy semantics.
-// The object pointed to is deleted when the last shared_ptr pointing to it
-// is destroyed or reset.
-//
-
-template<class T> class shared_ptr
-{
-private:
-
- // Borland 5.5.1 specific workaround
- typedef shared_ptr<T> this_type;
-
-public:
-
- typedef T element_type;
- typedef T value_type;
- typedef T * pointer;
- typedef typename boost::detail::shared_ptr_traits<T>::reference reference;
-
- shared_ptr(): px(0), pn() // never throws in 1.30+
- {
- }
-
- template<class Y>
- explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
- {
- boost::detail::sp_enable_shared_from_this( pn, p, p );
- }
-
- //
- // Requirements: D's copy constructor must not throw
- //
- // shared_ptr will release p by calling d(p)
- //
-
- template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
- {
- boost::detail::sp_enable_shared_from_this( pn, p, p );
- }
-
- // As above, but with allocator. A's copy constructor shall not throw.
-
- template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
- {
- boost::detail::sp_enable_shared_from_this( pn, p, p );
- }
-
-// generated copy constructor, assignment, destructor are fine...
-
-// except that Borland C++ has a bug, and g++ with -Wsynth warns
-#if defined(__BORLANDC__) || defined(__GNUC__)
-
- shared_ptr & operator=(shared_ptr const & r) // never throws
- {
- px = r.px;
- pn = r.pn; // shared_count::op= doesn't throw
- return *this;
- }
-
-#endif
-
- template<class Y>
- explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
- {
- // it is now safe to copy r.px, as pn(r.pn) did not throw
- px = r.px;
- }
-
- template<class Y>
- shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() ) // never throws
- {
- if( !pn.empty() )
- {
- px = r.px;
- }
- }
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- shared_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- shared_ptr( shared_ptr<Y> const & r )
-
-#endif
- : px( r.px ), pn( r.pn ) // never throws
- {
- }
-
- // aliasing
- template< class Y >
- shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn ) // never throws
- {
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
- {
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
- {
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
- {
- if(px == 0) // need to allocate new counter -- the cast failed
- {
- pn = boost::detail::shared_count();
- }
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
- {
- if(px == 0)
- {
- boost::throw_exception(std::bad_cast());
- }
- }
-
-#ifndef BOOST_NO_AUTO_PTR
-
- template<class Y>
- explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
- {
- Y * tmp = r.get();
- pn = boost::detail::shared_count(r);
- boost::detail::sp_enable_shared_from_this( pn, tmp, tmp );
- }
-
-#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
- template<class Ap>
- shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
- {
- typename Ap::element_type * tmp = r.get();
- pn = boost::detail::shared_count( r );
- boost::detail::sp_enable_shared_from_this( pn, tmp, tmp );
- }
-
-
-#endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif // BOOST_NO_AUTO_PTR
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
-
- template<class Y>
- shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
- {
- px = r.px;
- pn = r.pn; // shared_count::op= doesn't throw
- return *this;
- }
-
-#endif
-
-#ifndef BOOST_NO_AUTO_PTR
-
- template<class Y>
- shared_ptr & operator=( std::auto_ptr<Y> & r )
- {
- this_type(r).swap(*this);
- return *this;
- }
-
-#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
- template<class Ap>
- typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
- {
- this_type( r ).swap( *this );
- return *this;
- }
-
-
-#endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif // BOOST_NO_AUTO_PTR
-
-// Move support
-
-#if defined( BOOST_HAS_RVALUE_REFS )
-
- shared_ptr( shared_ptr && r ): px( r.px ), pn() // never throws
- {
- pn.swap( r.pn );
- r.px = 0;
- }
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- shared_ptr( shared_ptr<Y> && r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- shared_ptr( shared_ptr<Y> && r )
-
-#endif
- : px( r.px ), pn() // never throws
- {
- pn.swap( r.pn );
- r.px = 0;
- }
-
- shared_ptr & operator=( shared_ptr && r ) // never throws
- {
- this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
- return *this;
- }
-
- template<class Y>
- shared_ptr & operator=( shared_ptr<Y> && r ) // never throws
- {
- this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
- return *this;
- }
-
-#endif
-
- void reset() // never throws in 1.30+
- {
- this_type().swap(*this);
- }
-
- template<class Y> void reset(Y * p) // Y must be complete
- {
- BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
- this_type(p).swap(*this);
- }
-
- template<class Y, class D> void reset( Y * p, D d )
- {
- this_type( p, d ).swap( *this );
- }
-
- template<class Y, class D, class A> void reset( Y * p, D d, A a )
- {
- this_type( p, d, a ).swap( *this );
- }
-
- template<class Y> void reset( shared_ptr<Y> const & r, T * p )
- {
- this_type( r, p ).swap( *this );
- }
-
- reference operator* () const // never throws
- {
- BOOST_ASSERT(px != 0);
- return *px;
- }
-
- T * operator-> () const // never throws
- {
- BOOST_ASSERT(px != 0);
- return px;
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- // implicit conversion to "bool"
-
-#if ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
-
- operator bool () const
- {
- return px != 0;
- }
-
-#elif defined( _MANAGED )
-
- static void unspecified_bool( this_type*** )
- {
- }
-
- typedef void (*unspecified_bool_type)( this_type*** );
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: unspecified_bool;
- }
-
-#elif \
- ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
- ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
- ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
-
- typedef T * (this_type::*unspecified_bool_type)() const;
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: &this_type::get;
- }
-
-#else
-
- typedef T * this_type::*unspecified_bool_type;
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: &this_type::px;
- }
-
-#endif
-
- // operator! is redundant, but some compilers need it
-
- bool operator! () const // never throws
- {
- return px == 0;
- }
-
- bool unique() const // never throws
- {
- return pn.unique();
- }
-
- long use_count() const // never throws
- {
- return pn.use_count();
- }
-
- void swap(shared_ptr<T> & other) // never throws
- {
- std::swap(px, other.px);
- pn.swap(other.pn);
- }
-
- template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
- {
- return pn < rhs.pn;
- }
-
- void * _internal_get_deleter( detail::sp_typeinfo const & ti ) const
- {
- return pn.get_deleter( ti );
- }
-
- bool _internal_equiv( shared_ptr const & r ) const
- {
- return px == r.px && pn == r.pn;
- }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
-private:
-
- template<class Y> friend class shared_ptr;
- template<class Y> friend class weak_ptr;
-
-
-#endif
-
- T * px; // contained pointer
- boost::detail::shared_count pn; // reference counter
-
-}; // shared_ptr
-
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
-{
- return a.get() != b.get();
-}
-
-#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
-
-// Resolve the ambiguity between our op!= and the one in rel_ops
-
-template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
-{
- return a.get() != b.get();
-}
-
-#endif
-
-template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
-{
- return a._internal_less(b);
-}
-
-template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
- a.swap(b);
-}
-
-template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
-{
- return shared_ptr<T>(r, boost::detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
-{
- return shared_ptr<T>(r, boost::detail::const_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
-{
- return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
-}
-
-// shared_*_cast names are deprecated. Use *_pointer_cast instead.
-
-template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
-{
- return shared_ptr<T>(r, boost::detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
-{
- return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
-{
- return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
-{
- BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
- return shared_static_cast<T>(r);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr<T> const & p)
-{
- return p.get();
-}
-
-// operator<<
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) && (__GNUC__ < 3) )
-
-template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
-{
- os << p.get();
- return os;
-}
-
-#else
-
-// in STLport's no-iostreams mode no iostream symbols can be used
-#ifndef _STLP_NO_IOSTREAMS
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
-// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
-using std::basic_ostream;
-template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
-# else
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
-# endif
-{
- os << p.get();
- return os;
-}
-
-#endif // _STLP_NO_IOSTREAMS
-
-#endif // __GNUC__ < 3
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-// get_deleter
-
-#if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
- ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
- ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
-
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
-{
- void const * q = p._internal_get_deleter(BOOST_SP_TYPEID(D));
- return const_cast<D *>(static_cast<D const *>(q));
-}
-
-#else
-
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
-{
- return static_cast<D *>(p._internal_get_deleter(BOOST_SP_TYPEID(D)));
-}
-
-#endif
-
-// atomic access
-
-#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
-
-template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ )
-{
- return false;
-}
-
-template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
-{
- boost::detail::spinlock_pool<2>::scoped_lock lock( p );
- return *p;
-}
-
-template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order /*mo*/ )
-{
- return atomic_load( p );
-}
-
-template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
-{
- boost::detail::spinlock_pool<2>::scoped_lock lock( p );
- p->swap( r );
-}
-
-template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
-{
- atomic_store( p, r ); // std::move( r )
-}
-
-template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
-{
- boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
-
- sp.lock();
- p->swap( r );
- sp.unlock();
-
- return r; // return std::move( r )
-}
-
-template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
-{
- return atomic_exchange( p, r ); // std::move( r )
-}
-
-template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
-{
- boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
-
- sp.lock();
-
- if( p->_internal_equiv( *v ) )
- {
- p->swap( w );
-
- sp.unlock();
-
- return true;
- }
- else
- {
- shared_ptr<T> tmp( *p );
-
- sp.unlock();
-
- tmp.swap( *v );
- return false;
- }
-}
-
-template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order /*success*/, memory_order /*failure*/ )
-{
- return atomic_compare_exchange( p, v, w ); // std::move( w )
-}
-
-#endif
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
-#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/smart_ptr/shared_ptr.hpp>
#endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
// boost/throw_exception.hpp
//
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-// Copyright (c) 2008 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright (c) 2008-2009 Emil Dotchevski and Reverge Studios, Inc.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
#include <boost/detail/workaround.hpp>
#include <exception>
-#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( BOOST_NO_TYPEID )
-# define BOOST_EXCEPTION_DISABLE
-#endif
-
-#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, < 0x590 )
+#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x593) )
# define BOOST_EXCEPTION_DISABLE
#endif
# define BOOST_EXCEPTION_DISABLE
#endif
-#if !defined( BOOST_NO_EXCEPTIONS ) && !defined( BOOST_EXCEPTION_DISABLE )
-# include <boost/exception/enable_current_exception.hpp>
-# include <boost/exception/enable_error_info.hpp>
+#if !defined( BOOST_EXCEPTION_DISABLE )
+# include <boost/exception/exception.hpp>
+# include <boost/current_function.hpp>
+# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(::boost::enable_error_info(x) <<\
+ ::boost::throw_function(BOOST_CURRENT_FUNCTION) <<\
+ ::boost::throw_file(__FILE__) <<\
+ ::boost::throw_line((int)__LINE__))
+#else
+# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
#endif
namespace boost
// See http://www.boost.org/libs/tokenizer/ for documentation.
// Revision History:
-// 01 Oct 2004 Joaquín M López Muñoz
+// 01 Oct 2004 Joaquin M Lopez Munoz
// Workaround for a problem with string::assign in msvc-stlport
// 06 Apr 2004 John Bandela
// Fixed a bug involving using char_delimiter with a true input iterator
// Boost tokenizer.hpp -----------------------------------------------------//
-// © Copyright Jeremy Siek and John R. Bandela 2001.
+// (c) Copyright Jeremy Siek and John R. Bandela 2001.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
template<class T1, class T2>
inline bool lt(const T1& lhs, const T2& rhs) {
return lhs.get_head() < rhs.get_head() ||
- !(rhs.get_head() < lhs.get_head()) &&
- lt(lhs.get_tail(), rhs.get_tail());
+ ( !(rhs.get_head() < lhs.get_head()) &&
+ lt(lhs.get_tail(), rhs.get_tail()));
}
template<>
inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
template<class T1, class T2>
inline bool gt(const T1& lhs, const T2& rhs) {
return lhs.get_head() > rhs.get_head() ||
- !(rhs.get_head() > lhs.get_head()) &&
- gt(lhs.get_tail(), rhs.get_tail());
+ ( !(rhs.get_head() > lhs.get_head()) &&
+ gt(lhs.get_tail(), rhs.get_tail()));
}
template<>
inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
namespace detail {
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x5A0)
//
// For some reason this implementation stops Borlands compiler
// from dropping cv-qualifiers, it still fails with references
template< typename T >
struct alignment_of_impl
{
-#ifndef BOOST_ALIGNMENT_OF
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+ //
+ // With MSVC both the native __alignof operator
+ // and our own logic gets things wrong from time to time :-(
+ // Using a combination of the two seems to make the most of a bad job:
+ //
+ BOOST_STATIC_CONSTANT(std::size_t, value =
+ (::boost::detail::alignment_logic<
+ sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
+ __alignof(T)
+ >::value));
+#elif !defined(BOOST_ALIGNMENT_OF)
BOOST_STATIC_CONSTANT(std::size_t, value =
(::boost::detail::alignment_logic<
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
|| BOOST_WORKAROUND(BOOST_MSVC, <= 1301) \
|| !defined(__EDG_VERSION__) && BOOST_WORKAROUND(__GNUC__, < 3) \
|| BOOST_WORKAROUND(__IBMCPP__, < 600 ) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+ || BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \
|| defined(__ghs) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700) \
|| BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890)) \
namespace detail{
+#if defined( __CODEGEARC__ )
+ // wrap the impl as main trait provides additional MPL lambda support
+ template < typename T, std::size_t N >
+ struct extent_imp {
+ static const std::size_t value = __array_extent(T, N);
+ };
+
+#else
+
template <class T, std::size_t N>
struct extent_imp
{
};
#endif
#endif
-}
+
+#endif // non-CodeGear implementation
+} // ::boost::detail
template <class T, std::size_t N = 0>
struct extent
# define BOOST_IS_ENUM(T) __is_enum(T)
// This one doesn't quite always do the right thing:
// # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
-# define BOOST_ALIGNMENT_OF(T) __alignof(T)
+// This one fails if the default alignment has been changed with /Zp:
+// # define BOOST_ALIGNMENT_OF(T) __alignof(T)
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
-#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
+#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__)))
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_reference.hpp>
# include <boost/type_traits/is_volatile.hpp>
# define BOOST_IS_CLASS(T) __is_class(T)
# define BOOST_IS_ENUM(T) __is_enum(T)
# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
-# define BOOST_ALIGNMENT_OF(T) __alignof__(T)
+# if !defined(unix) || defined(__LP64__)
+ // GCC sometimes lies about alignment requirements
+ // of type double on 32-bit unix platforms, use the
+ // old implementation instead in that case:
+# define BOOST_ALIGNMENT_OF(T) __alignof__(T)
+# endif
+
+# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
+#endif
+
+# if defined(__CODEGEARC__)
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/is_volatile.hpp>
+# include <boost/type_traits/is_void.hpp>
+
+# define BOOST_IS_UNION(T) __is_union(T)
+# define BOOST_IS_POD(T) __is_pod(T)
+# define BOOST_IS_EMPTY(T) __is_empty(T)
+# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T) || is_void<T>::value)
+# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T) && !is_volatile<T>::value && !is_reference<T>::value || is_void<T>::value)
+# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile<T>::value || is_void<T>::value)
+# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || is_void<T>::value)
+# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T) || is_void<T>::value)
+# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T) && !is_volatile<T>::value && !is_reference<T>::value || is_void<T>::value)
+# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value || is_void<T>::value)
+# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+
+# define BOOST_IS_ABSTRACT(T) __is_abstract(T)
+# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_void<T>::value && !is_void<U>::value)
+# define BOOST_IS_CLASS(T) __is_class(T)
+# define BOOST_IS_CONVERTIBLE(T,U) (__is_convertible(T,U) || is_void<U>::value)
+# define BOOST_IS_ENUM(T) __is_enum(T)
+# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
+# define BOOST_ALIGNMENT_OF(T) alignof(T)
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
// GCC2 won't even parse this template if we embed the computation
// of s1 in the computation of value.
#ifdef __GNUC__
- BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(is_abstract_imp2<T>::template check_sig<T>(0)));
+ BOOST_STATIC_CONSTANT(std::size_t, s1 = sizeof(is_abstract_imp2<T>::template check_sig<T>(0)));
#else
#if BOOST_WORKAROUND(_MSC_FULL_VER, >= 140050000)
#pragma warning(push)
#pragma warning(disable:6334)
#endif
- BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(check_sig<T>(0)));
+ BOOST_STATIC_CONSTANT(std::size_t, s1 = sizeof(check_sig<T>(0)));
#if BOOST_WORKAROUND(_MSC_FULL_VER, >= 140050000)
#pragma warning(pop)
#endif
#ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED
#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED
+#if !defined( __CODEGEARC__ )
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/config.hpp>
+#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
+#if !defined(__CODEGEARC__)
namespace detail {
template< typename T >
};
} // namespace detail
+#endif
//* is a type T an arithmetic type described in the standard (3.9.1p8)
+#if defined(__CODEGEARC__)
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,__is_arithmetic(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,::boost::detail::is_arithmetic_impl<T>::value)
+#endif
} // namespace boost
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,__is_array(T))
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false)
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false)
#endif
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename Base,is_base_and_derived,Base,Base,false)
+#endif
+
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
# include <boost/type_traits/is_function.hpp>
#endif
+#endif // BOOST_IS_CLASS
+
#ifdef __EDG_VERSION__
# include <boost/type_traits/remove_cv.hpp>
#endif
-#endif // BOOST_IS_CLASS
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
+#if !defined( __CODEGEARC__ )
namespace detail {
template <typename T>
};
} // namespace detail
+#endif // !defined( __CODEGEARC__ )
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_compound,T,__is_compound(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_compound,T,::boost::detail::is_compound_impl<T>::value)
+#endif
} // namespace boost
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined( __CODEGEARC__ )
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T))
+
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
//* is a type T declared const - is_const<T>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
#endif
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false)
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(BOOST_ILLEGAL_CV_REFERENCES)
// these are illegal specialisations; cv-qualifies applied to
// references have no effect according to [8.3.2p1],
// C++ Builder requires them though as it treats cv-qualified
// function pointers to void*.
namespace boost {
+
+#if !defined( __CODEGEARC__ )
+
namespace detail {
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
} // namespace detail
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,::boost::detail::is_function_impl<T>::value)
+#endif // !defined( __CODEGEARC__ )
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,__is_function(T))
+#else
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,::boost::detail::is_function_impl<T>::value)
+#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
} // namespace detail
//* is a type T a fundamental type described in the standard (3.9.1)
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_fundamental,T,__is_fundamental(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_fundamental,T,::boost::detail::is_fundamental_impl<T>::value)
+#endif
} // namespace boost
//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3)
// as an extention we include long long, as this is likely to be added to the
// standard at a later date
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,__is_integral(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,false)
BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned char,true)
BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int64,true)
#endif
+#endif // non-CodeGear implementation
+
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
namespace boost {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,__is_member_function_pointer( T ))
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(
is_member_function_pointer
namespace boost {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,__is_member_pointer(T))
+#elif BOOST_WORKAROUND(__BORLANDC__, < 0x600)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true)
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,__is_pointer(T))
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
namespace detail {
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,__is_reference(T))
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T&,true)
-#if defined(__BORLANDC__) && !defined(__COMO__) && (__BORLANDC__ < 0x600)
+#if defined(BOOST_ILLEGAL_CV_REFERENCES)
// these are illegal specialisations; cv-qualifies applied to
// references have no effect according to [8.3.2p1],
// C++ Builder requires them though as it treats cv-qualified
namespace boost {
+#if !defined( __CODEGEARC__ )
+
namespace detail{
#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238)
}
+#endif // !defined( __CODEGEARC__ )
+
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_signed,T,__is_signed(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_signed,T,::boost::detail::is_signed_imp<T>::value)
+#endif
} // namespace boost
namespace boost {
+#if !defined( __CODEGEARC__ )
+
namespace detail{
#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238)
#endif
-
}
+#endif // !defined( __CODEGEARC__ )
+
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_unsigned,T,__is_unsigned(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_unsigned,T,::boost::detail::is_unsigned_imp<T>::value)
+#endif
} // namespace boost
namespace boost {
//* is a type T void - is_void<T>
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_void,T,__is_void(T))
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_void,T,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void,true)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const volatile,true)
#endif
+#endif // non-CodeGear implementation
+
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,__is_volatile(T))
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
//* is a type T declared volatile - is_volatile<T>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
#endif
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T&,false)
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(BOOST_ILLEGAL_CV_REFERENCES)
// these are illegal specialisations; cv-qualifies applied to
// references have no effect according to [8.3.2p1],
// C++ Builder requires them though as it treats cv-qualified
namespace boost {
+#if !defined( __CODEGEARC__ )
+
namespace detail{
template <class T, std::size_t N>
#endif
}
+#endif // !defined( __CODEGEARC__ )
+
+#if defined( __CODEGEARC__ )
+BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(rank,T,__array_rank(T))
+#else
BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(rank,T,(::boost::detail::rank_imp<T,0>::value))
+#endif
} // namespace boost
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T const[N],typename boost::remove_all_extents<T const>::type type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T volatile[N],typename boost::remove_all_extents<T volatile>::type type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T const volatile[N],typename boost::remove_all_extents<T const volatile>::type type)
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_all_extents,T[],typename boost::remove_all_extents<T>::type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_all_extents,T const[],typename boost::remove_all_extents<T const>::type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_all_extents,T volatile[],typename boost::remove_all_extents<T volatile>::type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const[N],T const type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T volatile[N],T volatile type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const volatile[N],T const volatile type)
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T[],T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const[],T const)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T volatile[],T volatile)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T const[N],T const type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T volatile[N],T volatile type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T const volatile[N],T const volatile type)
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_extent,T[],T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_extent,T const[],T const)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_extent,T volatile[],T volatile)
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T&,T)
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(BOOST_ILLEGAL_CV_REFERENCES)
// these are illegal specialisations; cv-qualifies applied to
// references have no effect according to [8.3.2p1],
// C++ Builder requires them though as it treats cv-qualified
typedef ::boost::align::a16 max_align;
+//#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true)
+//#endif
}
template <std::size_t N> struct type_with_alignment
#define BOOST_UTILITY_HPP
#include <boost/utility/addressof.hpp>
-#include <boost/utility/base_from_member.hpp>
+#include <boost/utility/base_from_member.hpp>
+#include <boost/utility/binary.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/checked_delete.hpp>
#include <boost/next_prior.hpp>
namespace detail
{
+template<class T> struct addr_impl_ref
+{
+ T & v_;
+
+ inline addr_impl_ref( T & v ): v_( v ) {}
+ inline operator T& () const { return v_; }
+};
+
template<class T> struct addressof_impl
{
static inline T * f( T & v, long )
template<class T> T * addressof( T & v )
{
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
+
return boost::detail::addressof_impl<T>::f( v, 0 );
+
+#else
+
+ return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+
+#endif
}
+#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
+
+namespace detail
+{
+
+template<class T> struct addressof_addp
+{
+ typedef T * type;
+};
+
+} // namespace detail
+
+template< class T, std::size_t N >
+typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
+{
+ return &t;
+}
+
+#endif
+
// Borland doesn't like casting an array reference to a char reference
// but these overloads work around the problem.
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
template<typename T,std::size_t N>
T (*addressof(T (&t)[N]))[N]
{
{
return reinterpret_cast<const T(*)[N]>(&t);
}
-# endif
+#endif
} // namespace boost
// Boost enable_if library
-// Copyright 2003 © The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// BOOST_VERSION / 100 % 1000 is the minor version
// BOOST_VERSION / 100000 is the major version
-#define BOOST_VERSION 103600
+#define BOOST_VERSION 103900
//
// BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
// number, y is the minor version number, and z is the patch level if not 0.
// This is used by <config/auto_link.hpp> to select which library version to link to.
-#define BOOST_LIB_VERSION "1_36"
+#define BOOST_LIB_VERSION "1_39"
#endif
//
// Copyright (c) 2001, 2002, 2003 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
//
-#include <memory> // boost.TR1 include order fix
-#include <boost/detail/shared_count.hpp>
-#include <boost/shared_ptr.hpp>
-
-#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
-namespace boost
-{
-
-template<class T> class weak_ptr
-{
-private:
-
- // Borland 5.5.1 specific workarounds
- typedef weak_ptr<T> this_type;
-
-public:
-
- typedef T element_type;
-
- weak_ptr(): px(0), pn() // never throws in 1.30+
- {
- }
-
-// generated copy constructor, assignment, destructor are fine
-
-
-//
-// The "obvious" converting constructor implementation:
-//
-// template<class Y>
-// weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
-// {
-// }
-//
-// has a serious problem.
-//
-// r.px may already have been invalidated. The px(r.px)
-// conversion may require access to *r.px (virtual inheritance).
-//
-// It is not possible to avoid spurious access violations since
-// in multithreaded programs r.px may be invalidated at any point.
-//
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- weak_ptr( weak_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- weak_ptr( weak_ptr<Y> const & r )
-
-#endif
- : pn(r.pn) // never throws
- {
- px = r.lock().get();
- }
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- weak_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- weak_ptr( shared_ptr<Y> const & r )
-
-#endif
- : px( r.px ), pn( r.pn ) // never throws
- {
- }
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
-
- template<class Y>
- weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
- {
- px = r.lock().get();
- pn = r.pn;
- return *this;
- }
-
- template<class Y>
- weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
- {
- px = r.px;
- pn = r.pn;
- return *this;
- }
-
-#endif
-
- shared_ptr<T> lock() const // never throws
- {
- return shared_ptr<element_type>( *this, boost::detail::sp_nothrow_tag() );
- }
-
- long use_count() const // never throws
- {
- return pn.use_count();
- }
-
- bool expired() const // never throws
- {
- return pn.use_count() == 0;
- }
-
- void reset() // never throws in 1.30+
- {
- this_type().swap(*this);
- }
-
- void swap(this_type & other) // never throws
- {
- std::swap(px, other.px);
- pn.swap(other.pn);
- }
-
- void _internal_assign(T * px2, boost::detail::shared_count const & pn2)
- {
- px = px2;
- pn = pn2;
- }
-
- template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
- {
- return pn < rhs.pn;
- }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
-private:
-
- template<class Y> friend class weak_ptr;
- template<class Y> friend class shared_ptr;
-
-#endif
-
- T * px; // contained pointer
- boost::detail::weak_count pn; // reference counter
-
-}; // weak_ptr
-
-template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
-{
- return a._internal_less(b);
-}
-
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
-{
- a.swap(b);
-}
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
+#include <boost/smart_ptr/weak_ptr.hpp>
#endif // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED
projects / features.git / commitdiff