From 70479c5282509b94f1c5c71db680b7f2d88db96a Mon Sep 17 00:00:00 2001 From: =?utf8?q?Lars=20Gullik=20Bj=C3=B8nnes?= Date: Wed, 29 Aug 2001 22:33:34 +0000 Subject: [PATCH] update from boost cvs git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@2623 a592a061-630c-0410-9148-cb99ea01b6c8 --- boost/boost/array.hpp | 5 +- boost/boost/config.hpp | 23 +- boost/boost/crc.hpp | 11 +- boost/boost/detail/limits.hpp | 9 +- boost/boost/smart_ptr.hpp | 52 +- boost/boost/tuple/detail/tuple_basic.hpp | 733 ++++++++++++++++++ .../detail/tuple_basic_no_partial_spec.hpp | 654 ++++++++++++++++ boost/boost/tuple/reference_wrappers.hpp | 57 ++ boost/boost/tuple/tuple.hpp | 36 + boost/boost/tuple/tuple_comparison.hpp | 180 +++++ boost/boost/tuple/tuple_io.hpp | 501 ++++++++++++ boost/boost/type_traits/alignment_traits.hpp | 84 ++ boost/boost/type_traits/arithmetic_traits.hpp | 270 +++++++ boost/boost/type_traits/composite_traits.hpp | 537 +++++++++++++ boost/boost/type_traits/conversion_traits.hpp | 229 ++++++ boost/boost/type_traits/cv_traits.hpp | 279 +++++++ boost/boost/type_traits/function_traits.hpp | 148 ++++ boost/boost/type_traits/fwd.hpp | 141 ++++ boost/boost/type_traits/ice.hpp | 87 +++ boost/boost/type_traits/object_traits.hpp | 350 +++++++++ boost/boost/type_traits/same_traits.hpp | 99 +++ boost/boost/type_traits/transform_traits.hpp | 200 +++++ .../type_traits/transform_traits_spec.hpp | 78 ++ boost/boost/type_traits/type_traits_test.hpp | 393 ++++++++++ boost/boost/utility.hpp | 25 - 25 files changed, 5110 insertions(+), 71 deletions(-) create mode 100644 boost/boost/tuple/detail/tuple_basic.hpp create mode 100644 boost/boost/tuple/detail/tuple_basic_no_partial_spec.hpp create mode 100644 boost/boost/tuple/reference_wrappers.hpp create mode 100644 boost/boost/tuple/tuple.hpp create mode 100644 boost/boost/tuple/tuple_comparison.hpp create mode 100644 boost/boost/tuple/tuple_io.hpp create mode 100644 boost/boost/type_traits/alignment_traits.hpp create mode 100644 boost/boost/type_traits/arithmetic_traits.hpp create mode 100644 boost/boost/type_traits/composite_traits.hpp create mode 100644 boost/boost/type_traits/conversion_traits.hpp create mode 100644 boost/boost/type_traits/cv_traits.hpp create mode 100644 boost/boost/type_traits/function_traits.hpp create mode 100644 boost/boost/type_traits/fwd.hpp create mode 100644 boost/boost/type_traits/ice.hpp create mode 100644 boost/boost/type_traits/object_traits.hpp create mode 100644 boost/boost/type_traits/same_traits.hpp create mode 100644 boost/boost/type_traits/transform_traits.hpp create mode 100644 boost/boost/type_traits/transform_traits_spec.hpp create mode 100644 boost/boost/type_traits/type_traits_test.hpp diff --git a/boost/boost/array.hpp b/boost/boost/array.hpp index 12621f7444..0840003b62 100644 --- a/boost/boost/array.hpp +++ b/boost/boost/array.hpp @@ -5,12 +5,13 @@ * http://www.josuttis.com/cppcode * for details and the latest version. * - * (C) Copyright Nicolai M. Josuttis 1999. + * (C) Copyright Nicolai M. Josuttis 2001. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears 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. * + * 05 Aug 2001 - minor update (Nico Josuttis) * 20 Jan 2001 - STLport fix (Beman Dawes) * 29 Sep 2000 - Initial Revision (Nico Josuttis) */ @@ -49,7 +50,7 @@ namespace boost { const_iterator end() const { return elems+N; } // reverse iterator support -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; #else diff --git a/boost/boost/config.hpp b/boost/boost/config.hpp index cbf0a73fc0..ed72496756 100644 --- a/boost/boost/config.hpp +++ b/boost/boost/config.hpp @@ -59,7 +59,7 @@ #ifndef BOOST_CONFIG_HPP #define BOOST_CONFIG_HPP -#define BOOST_VERSION 102300 +#define BOOST_VERSION 102400 // BOOST_VERSION % 100 is the sub-minor version // BOOST_VERSION / 100 % 1000 is the minor version @@ -74,11 +74,11 @@ // burden where it should be, on non-conforming compilers. In the future, // hopefully, less rather than more conformance flags will have to be defined. -// BOOST_NO_CV_SPECIALIZATIONS: if template specialisations for cv-qualified types -// conflict with a specialistaion for unqualififed type. +// BOOST_NO_CV_SPECIALIZATIONS: if template specializations for cv-qualified +// types conflict with a specialization for unqualififed type. -// BOOST_NO_CV_VOID_SPECIALIZATIONS: if template specialisations for cv-void types -// conflict with a specialistaion for void. +// BOOST_NO_CV_VOID_SPECIALIZATIONS: if template specializations for cv-void +// types conflict with a specialization for void. // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP: Compiler does not implement // argument-dependent lookup (also named Koenig lookup); see std::3.4.2 @@ -294,6 +294,9 @@ # elif defined __COMO__ # if __COMO_VERSION__ <= 4245 # define BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS +# if defined(_MSC_VER) && _MSC_VER <= 1200 +# define BOOST_NO_STDC_NAMESPACE +# endif # endif // Compaq Tru64 Unix cxx --------------------------------------------------- @@ -310,7 +313,7 @@ # define BOOST_NO_AUTO_PTR # endif # if __GNUC__ == 2 && __GNUC_MINOR__ <= 97 -# include "LString.h" // not sure this is the right way to do this -JGS +# include // not sure this is the right way to do this -JGS # if defined(__BASTRING__) && !defined(__GLIBCPP__) && !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS // this should only detect the stdlibc++ that ships with gcc, and // not any replacements that may be installed... @@ -410,8 +413,10 @@ // Metrowerks CodeWarrior -------------------------------------------------// # elif defined __MWERKS__ -# if __MWERKS__ <= 0x2401 // 6.2 +# if __MWERKS__ <= 0x2405 // 7 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# endif +# if __MWERKS__ <= 0x2401 // 6.2 # define BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING # endif # if __MWERKS__ <= 0x2301 // 5.3 @@ -518,7 +523,9 @@ # ifndef _GLOBAL_USING // can be defined in yvals.h # define BOOST_NO_STDC_NAMESPACE # endif -# define BOOST_MSVC_STD_ITERATOR +# if _CPPLIB_VER < 308 // fix due to kensai@pacbell.net +# define BOOST_MSVC_STD_ITERATOR +# endif # else # define BOOST_MSVC_STD_ITERATOR # define BOOST_NO_SLIST diff --git a/boost/boost/crc.hpp b/boost/boost/crc.hpp index 2ab8aab795..4658ae4abe 100644 --- a/boost/boost/crc.hpp +++ b/boost/boost/crc.hpp @@ -38,7 +38,7 @@ // arguments explicitly specified. At least one compiler that needs this // workaround also needs the default value for the dummy argument to be // specified in the definition. -#ifndef BOOST_MSVC +#ifndef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS #define BOOST_CRC_DUMMY_PARM_TYPE #define BOOST_CRC_DUMMY_INIT #define BOOST_ACRC_DUMMY_PARM_TYPE @@ -280,15 +280,10 @@ namespace detail typedef typename base_type::least least; typedef typename base_type::fast fast; -#ifdef __DECCXX - static const least high_bit = 1ul << (Bits - 1u); - static const fast high_bit_fast = 1ul << (Bits - 1u); -#else BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << ( Bits - 1u )) ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << ( Bits - 1u )) ); -#endif }; // boost::detail::high_uint_t @@ -345,11 +340,7 @@ namespace detail BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast ); #endif -#ifdef __DECCXX - static const least sig_bits = (~( ~(0ul) << Bits)); -#else BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) ); -#endif BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); }; // boost::detail::mask_uint_t diff --git a/boost/boost/detail/limits.hpp b/boost/boost/detail/limits.hpp index e1da405986..cb296ca857 100644 --- a/boost/boost/detail/limits.hpp +++ b/boost/boost/detail/limits.hpp @@ -20,6 +20,8 @@ /* * Revision history: + * 10 Aug 2001: + * Added MIPS (big endian) to the big endian family. (Jens Maurer) * 13 Apr 2001: * Added powerpc to the big endian family. (Jeremy Siek) * 5 Apr 2001: @@ -33,11 +35,14 @@ #include #include +#include // for WCHAR_MIN and WCHAR_MAX #include -#if defined(__sparc) || defined(__sparc__) || defined(__powerpc__) || defined(__hppa) +#if defined(__sparc) || defined(__sparc__) || defined(__powerpc__) || defined(__ppc__) || defined(__hppa) || defined(_MIPSEB) #define BOOST_BIG_ENDIAN -#elif !defined(__i386__) +#elif defined(__i386__) +#define BOOST_LITTLE_ENDIAN +#else #error The file boost/detail/limits.hpp needs to be set up for your CPU type. #endif diff --git a/boost/boost/smart_ptr.hpp b/boost/boost/smart_ptr.hpp index fbc6b6a0cd..7de81b19ec 100644 --- a/boost/boost/smart_ptr.hpp +++ b/boost/boost/smart_ptr.hpp @@ -17,6 +17,8 @@ // See http://www.boost.org for most recent version including documentation. // Revision History +// 6 Jul 01 Reorder shared_ptr code so VC++ 6 member templates work, allowing +// polymorphic pointers to now work with that compiler (Gary Powell) // 21 May 01 Require complete type where incomplete type is unsafe. // (suggested by Vladimir Prus) // 21 May 01 operator= fails if operand transitively owned by *this, as in a @@ -69,13 +71,13 @@ #include // for BOOST_STATIC_ASSERT #ifdef LYX_NO_EXCEPTIONS -#include +#include #endif #ifdef BOOST_MSVC // moved here to work around VC++ compiler crash # pragma warning(push) # pragma warning(disable:4284) // return type for 'identifier::operator->' is not a UDT or reference to a UDT. Will produce errors if applied using infix notation -#endif +#endif namespace boost { @@ -146,23 +148,16 @@ template class shared_ptr { explicit shared_ptr(T* p =0) : px(p) { #ifndef LYX_NO_EXCEPTIONS try { pn = new long(1); } // fix: prevent leak if new throws - catch (...) { checked_delete(p); throw; } + catch (...) { checked_delete(p); throw; } #else - pn = new long(1); - assert(pn != 0); + pn = new long(1); + assert(pn != 0); #endif } - shared_ptr(const shared_ptr& r) : px(r.px) { ++*(pn = r.pn); } // never throws - ~shared_ptr() { dispose(); } - shared_ptr& operator=(const shared_ptr& r) { - share(r.px,r.pn); - return *this; - } - -#if !defined( BOOST_NO_MEMBER_TEMPLATES ) +#if !defined( BOOST_NO_MEMBER_TEMPLATES ) || defined (BOOST_MSVC6_MEMBER_TEMPLATES) template shared_ptr(const shared_ptr& r) : px(r.px) { // never throws ++*(pn = r.pn); @@ -216,11 +211,20 @@ template class shared_ptr { #endif #endif + // The assignment operator and the copy constructor must come after + // the templated versions for MSVC6 to work. (Gary Powell) + shared_ptr(const shared_ptr& r) : px(r.px) { ++*(pn = r.pn); } // never throws + + shared_ptr& operator=(const shared_ptr& r) { + share(r.px,r.pn); + return *this; + } + void reset(T* p=0) { if ( px == p ) return; // fix: self-assignment safe if (--*pn == 0) { checked_delete(px); } else { // allocate new reference counter -#ifndef LYX_NO_EXCEPTIONS +#ifndef LYX_NO_EXCEPTIONS try { pn = new long; } // fix: prevent leak if new throws catch (...) { ++*pn; // undo effect of --*pn above to meet effects guarantee @@ -228,8 +232,8 @@ template class shared_ptr { throw; } // catch #else - pn = new long; - assert(pn != 0); + pn = new long; + assert(pn != 0); #endif } // allocate new reference counter *pn = 1; @@ -253,7 +257,7 @@ template class shared_ptr { // Tasteless as this may seem, making all members public allows member templates // to work in the absence of member template friends. (Matthew Langston) // Don't split this line into two; that causes problems for some GCC 2.95.2 builds -#if defined(BOOST_NO_MEMBER_TEMPLATES) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) +#if ( defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) ) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) private: #endif @@ -299,10 +303,10 @@ template class shared_array { explicit shared_array(T* p =0) : px(p) { #ifndef LYX_NO_EXCEPTIONS try { pn = new long(1); } // fix: prevent leak if new throws - catch (...) { checked_array_delete(p); throw; } + catch (...) { checked_array_delete(p); throw; } #else - pn = new long(1); - assert(pn != 0); + pn = new long(1); + assert(pn != 0); #endif } @@ -334,8 +338,8 @@ template class shared_array { throw; } // catch #else - pn = new long; - assert(pn != 0); + pn = new long; + assert(pn != 0); #endif } // allocate new reference counter *pn = 1; @@ -422,8 +426,8 @@ template #endif // ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #ifdef BOOST_MSVC -#pragma warning(pop) -#endif +# pragma warning(pop) +#endif #endif // BOOST_SMART_PTR_HPP diff --git a/boost/boost/tuple/detail/tuple_basic.hpp b/boost/boost/tuple/detail/tuple_basic.hpp new file mode 100644 index 0000000000..779e4dd405 --- /dev/null +++ b/boost/boost/tuple/detail/tuple_basic.hpp @@ -0,0 +1,733 @@ +// tuple_basic.hpp ----------------------------------------------------- + +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +// For more information, see http://www.boost.org + +// Outside help: +// This and that, Gary Powell. +// Fixed return types for get_head/get_tail +// ( and other bugs ) per suggestion of Jens Maurer +// simplified element type accessors + bug fix (Jeremy Siek) +// Several changes/additions according to suggestions by Doug Gregor, +// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis, +// David Abrahams. + +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_BASIC_HPP +#define BOOST_TUPLE_BASIC_HPP + + +#include // needed for the assignment from pair to tuple + +#include "boost/type_traits/cv_traits.hpp" + +namespace boost { + +// -- null_type -------------------------------------------------------- +struct null_type {}; + +// a helper function to provide a const null_type type temporary +namespace detail { +namespace tuples { + inline const null_type cnull_type() { return null_type(); } +} // end tuples +} // end detail + +// - cons forward declaration ----------------------------------------------- +template struct cons; + + +// - tuple forward declaration ----------------------------------------------- +template < + class T0 = null_type, class T1 = null_type, class T2 = null_type, + class T3 = null_type, class T4 = null_type, class T5 = null_type, + class T6 = null_type, class T7 = null_type, class T8 = null_type, + class T9 = null_type> +class tuple; + +// tuple_length forward declaration +template struct tuple_length; + + + +namespace detail { +namespace tuples { + +// -- generate error template, referencing to non-existing members of this +// template is used to produce compilation errors intentionally +template +class generate_error; + +// tuple default argument wrappers --------------------------------------- +// Work for non-reference types, intentionally not for references +template +struct default_arg { + +// Non-class temporaries cannot have qualifiers. +// To prevent f to return for example const int, we remove cv-qualifiers +// from all temporaries. + static typename boost::remove_cv::type f() { return T(); } +}; + +template +struct default_arg { + static T& f() { + return generate_error::no_default_values_for_reference_types; + } +}; + +// - cons getters -------------------------------------------------------- +// called: element::get(aTuple) + +template< int N > +struct element { + template + inline static RET get(const cons& t) + { + return element::template get(t.tail); + } + template + inline static RET get(cons& t) + { + return element::template get(t.tail); + } +}; + +template<> +struct element<0> { + template + inline static RET get(const cons& t) + { + return t.head; + } + template + inline static RET get(cons& t) + { + return t.head; + } +}; + +} // end of namespace tuples +} // end of namespace detail + + +// -cons type accessors ---------------------------------------- +// typename tuple_element::type gets the type of the +// Nth element ot T, first element is at index 0 +// ------------------------------------------------------- + +template +struct tuple_element +{ +private: + typedef typename T::tail_type Next; +public: + typedef typename tuple_element::type type; +}; +template +struct tuple_element<0,T> +{ + typedef typename T::head_type type; +}; + +// -get function templates ----------------------------------------------- +// Usage: get(aTuple) + +// -- some traits classes for get functions + +// access traits lifted from detail namespace to be part of the interface, +// (Joel de Guzman's suggestion). Rationale: get functions are part of the +// interface, so should the way to express their return types be. + +template struct tuple_access_traits { + typedef const T& const_type; + typedef T& non_const_type; + + typedef const typename boost::remove_cv::type& parameter_type; +// used as the tuple constructors parameter types +// Rationale: non-reference tuple element types can be cv-qualified. +// It should be possible to initialize such types with temporaries, +// and when binding temporaries to references, the reference must +// be non-volatile and const. 8.5.3. (5) +}; + +template struct tuple_access_traits { + + typedef T& const_type; + typedef T& non_const_type; + + typedef T& parameter_type; +}; + + +// get function for non-const cons-lists, returns a reference to the element + +template +inline typename tuple_access_traits< + typename tuple_element >::type + >::non_const_type +get(cons& c) { + return detail::tuples::element::template + get< + typename tuple_access_traits< + typename tuple_element >::type + >::non_const_type>(c); +} + +// get function for const cons-lists, returns a const reference to +// the element. If the element is a reference, returns the reference +// as such (that is, can return a non-const reference) +template +inline typename tuple_access_traits< + typename tuple_element >::type + >::const_type +get(const cons& c) { + return detail::tuples::element::template + get< + typename tuple_access_traits< + typename tuple_element >::type + >::const_type>(c); +} + + + + +// -- the cons template -------------------------------------------------- + +template +struct cons { + + typedef HT head_type; + typedef TT tail_type; + + head_type head; + tail_type tail; + + typename tuple_access_traits::non_const_type + get_head() { return head; } + + typename tuple_access_traits::non_const_type + get_tail() { return tail; } + + typename tuple_access_traits::const_type + get_head() const { return head; } + + typename tuple_access_traits::const_type + get_tail() const { return tail; } + + cons(typename tuple_access_traits::parameter_type h, + const tail_type& t) + : head (h), tail(t) {} + + template + cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) + : head (t1), + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::tuples::cnull_type()) + {} + + template + cons( const cons& u ) : head(u.head), tail(u.tail) {} + + template + cons& operator=( const cons& u ) { + head=u.head; tail=u.tail; return *this; + } + + // must define assignment operator explicitly, implicit version is + // illformed if HT is a reference (12.8. (12)) + cons& operator=(const cons& u) { + head = u.head; tail = u.tail; return *this; + } + + template + cons& operator=( const std::pair& u ) { + BOOST_STATIC_ASSERT(tuple_length::value == 2); // check length = 2 + head = u.first; tail.head = u.second; return *this; + } + + // get member functions (non-const and const) + template + typename tuple_access_traits< + typename tuple_element >::type + >::non_const_type + get() { + return boost::get(*this); // delegate to non-member get + } + + template + typename tuple_access_traits< + typename tuple_element >::type + >::const_type + get() const { + return boost::get(*this); // delegate to non-member get + } +}; + +template +struct cons { + + typedef HT head_type; + typedef null_type tail_type; + + head_type head; + + typename tuple_access_traits::non_const_type + get_head() { return head; } + + null_type get_tail() { return null_type(); } + + typename tuple_access_traits::const_type + get_head() const { return head; } + + const null_type get_tail() const { return null_type(); } + + cons(typename tuple_access_traits::parameter_type h, + const null_type& = null_type()) + : head (h) {} + + template + cons(T1& t1, const null_type&, const null_type&, const null_type&, + const null_type&, const null_type&, const null_type&, + const null_type&, const null_type&, const null_type&) + : head (t1) {} + + template + cons( const cons& u ) : head(u.head) {} + + template + cons& operator=(const cons& u ) + { head = u.head; return *this; } + + // must define assignment operator explicitely, implicit version + // is illformed if HT is a reference + cons& operator=(const cons& u) { head = u.head; return *this; } + + template + typename tuple_access_traits< + typename tuple_element::type + >::non_const_type + get() { + return boost::get(*this); + } + + template + typename tuple_access_traits< + typename tuple_element::type + >::const_type + get() const { + return boost::get(*this); + } + +}; + +// templates for finding out the length of the tuple ------------------- + +template +struct tuple_length { + BOOST_STATIC_CONSTANT(int, value = 1 + tuple_length::value); +}; + +template<> +struct tuple_length { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + + +namespace detail { +namespace tuples { + +// Tuple to cons mapper -------------------------------------------------- +template +struct map_tuple_to_cons +{ + typedef cons::type + > type; +}; + +// The empty tuple is a null_type +template <> +struct map_tuple_to_cons +{ + typedef null_type type; +}; + +} // end tuples +} // end detail + +// ------------------------------------------------------------------- +// -- tuple ------------------------------------------------------ +template + +class tuple : + public detail::tuples::map_tuple_to_cons::type +{ +public: + typedef typename + detail::tuples::map_tuple_to_cons::type inherited; + typedef typename inherited::head_type head_type; + typedef typename inherited::tail_type tail_type; + + +// tuple_access_traits::parameter_type takes non-reference types as const T& + explicit tuple( + typename tuple_access_traits::parameter_type t0 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t1 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t2 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t3 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t4 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t5 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t6 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t7 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t8 + = detail::tuples::default_arg::f(), + typename tuple_access_traits::parameter_type t9 + = detail::tuples::default_arg::f()) + + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {} + + template + tuple(const cons& p) : inherited(p) {} + + template + tuple& operator=(const cons& k) { + inherited::operator=(k); + return *this; + } + + template + tuple& operator=(const std::pair& k) { + BOOST_STATIC_ASSERT(tuple_length::value == 2);// check_length = 2 + this->head = k.first; + this->tail.head = k.second; + return *this; + } + +}; + +// The empty tuple +template <> +class tuple : + public null_type +{ +public: + typedef null_type inherited; +}; + + +// Swallows any assignment (by Doug Gregor) +namespace detail { +namespace tuples { + +struct swallow_assign { + + template + swallow_assign& operator=(const T&) { + return *this; + } +}; +} // namespace tuples +} // namespace detail + +// "ignore" allows tuple positions to be ignored when using "tie". +namespace { + detail::tuples::swallow_assign ignore; +} + +// --------------------------------------------------------------------------- +// The call_traits for make_tuple +// Honours the reference_wrapper class. + +// Must be instantiated with plain or const plain types (not with references) + +// from template foo(const T& t) : make_tuple_traits::type +// from template foo(T& t) : make_tuple_traits::type + +// Conversions: +// T -> T, +// references -> compile_time_error +// reference_wrapper -> T& +// const reference_wrapper -> T& +// array -> const ref array + + +template +struct make_tuple_traits { + typedef T type; + + // commented away, see below (JJ) + // typedef typename IF< + // boost::is_function::value, + // T&, + // T>::RET type; + +}; + +// The is_function test was there originally for plain function types, +// which can't be stored as such (we must either store them as references or +// pointers). Such a type could be formed if make_tuple was called with a +// reference to a function. +// But this would mean that a const qualified function type was formed in +// the make_tuple function and hence make_tuple can't take a function +// reference as a parameter, and thus T can't be a function type. +// So is_function test was removed. +// (14.8.3. says that type deduction fails if a cv-qualified function type +// is created. (It only applies for the case of explicitly specifying template +// args, though?)) (JJ) + +template +struct make_tuple_traits { + typedef typename + detail::tuples::generate_error:: + do_not_use_with_reference_type error; +}; + +// Arrays can't be stored as plain types; convert them to references. +// All arrays are converted to const. This is because make_tuple takes its +// parameters as const T& and thus the knowledge of the potential +// non-constness of actual argument is lost. +template struct make_tuple_traits { + typedef const T (&type)[n]; +}; + +template +struct make_tuple_traits { + typedef const T (&type)[n]; +}; + +template struct make_tuple_traits { + typedef const volatile T (&type)[n]; +}; + +template +struct make_tuple_traits { + typedef const volatile T (&type)[n]; +}; + +template +struct make_tuple_traits >{ + typedef T& type; +}; + +template +struct make_tuple_traits >{ + typedef T& type; +}; + + + + +namespace detail { +namespace tuples { + +// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's +// suggestion) +template < + class T0 = null_type, class T1 = null_type, class T2 = null_type, + class T3 = null_type, class T4 = null_type, class T5 = null_type, + class T6 = null_type, class T7 = null_type, class T8 = null_type, + class T9 = null_type +> +struct make_tuple_mapper { + typedef + tuple::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type> type; +}; + +} // end tuples +} // end detail + +// -make_tuple function templates ----------------------------------- +inline tuple<> make_tuple() { + return tuple<>(); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0) { + return typename boost::detail::tuples::make_tuple_mapper::type(t0); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1) { + return typename boost::detail::tuples::make_tuple_mapper::type(t0, t1); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2) { + return typename boost::detail::tuples::make_tuple_mapper::type(t0, t1, t2); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) { + return typename boost::detail::tuples::make_tuple_mapper::type + (t0, t1, t2, t3); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4) { + return typename boost::detail::tuples::make_tuple_mapper::type + (t0, t1, t2, t3, t4); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5) { + return typename boost::detail::tuples::make_tuple_mapper::type + (t0, t1, t2, t3, t4, t5); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6) { + return typename boost::detail::tuples::make_tuple_mapper + ::type + (t0, t1, t2, t3, t4, t5, t6); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7) { + return typename boost::detail::tuples::make_tuple_mapper + ::type + (t0, t1, t2, t3, t4, t5, t6, t7); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper + ::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7, + const T8& t8) { + return typename boost::detail::tuples::make_tuple_mapper + ::type + (t0, t1, t2, t3, t4, t5, t6, t7, t8); +} + +template +inline typename boost::detail::tuples::make_tuple_mapper + ::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7, + const T8& t8, const T9& t9) { + return typename boost::detail::tuples::make_tuple_mapper + ::type + (t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); +} + + + +// Tie function templates ------------------------------------------------- +template +inline tuple tie(T1& t1) { + return tuple (t1); +} + +template +inline tuple tie(T1& t1, T2& t2) { + return tuple (t1, t2); +} + +template +inline tuple tie(T1& t1, T2& t2, T3& t3) { + return tuple (t1, t2, t3); +} + +template +inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4) { + return tuple (t1, t2, t3, t4); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) { + return tuple (t1, t2, t3, t4, t5); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) { + return tuple (t1, t2, t3, t4, t5, t6); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) { + return tuple (t1, t2, t3, t4, t5, t6, t7); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) { + return tuple + (t1, t2, t3, t4, t5, t6, t7, t8); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, + T9& t9) { + return tuple + (t1, t2, t3, t4, t5, t6, t7, t8, t9); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, + T9& t9, T10& t10) { + return tuple + (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); +} + +} // end of namespace boost + + +#endif // BOOST_TUPLE_BASIC_HPP + + diff --git a/boost/boost/tuple/detail/tuple_basic_no_partial_spec.hpp b/boost/boost/tuple/detail/tuple_basic_no_partial_spec.hpp new file mode 100644 index 0000000000..fa197b1968 --- /dev/null +++ b/boost/boost/tuple/detail/tuple_basic_no_partial_spec.hpp @@ -0,0 +1,654 @@ +// - tuple_basic_no_partial_spec.hpp ----------------------------------------- + +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu) +// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +// For more information, see http://www.boost.org or http://lambda.cs.utu.fi + +// Revision History +// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG) +// 10 02 01 Fixed "null_type" constructors. +// Implemented comparison operators globally. +// Hide element_type_ref and element_type_const_ref. +// (DG). +// 09 02 01 Extended to tuples of length 10. Changed comparison for +// operator<() +// to the same used by std::pair<>, added cnull_type() (GP) +// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG) + +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP +#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP + +#include "boost/type_traits.hpp" + +#if defined BOOST_MSVC +#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored +#pragma warning(disable:4181) // qualifier applied to reference type ignored +#pragma warning(disable:4227) // qualifier applied to reference type ignored +#endif + +namespace boost { + + // null_type denotes the end of a list built with "cons" + struct null_type + { + null_type() {} + null_type(const null_type&, const null_type&) {} + }; + + // a helper function to provide a const null_type type temporary + inline const null_type cnull_type() { return null_type(); } + + namespace detail { + namespace tuples { + // Takes a pointer and routes all assignments to whatever it points to + template + struct assign_to_pointee + { + public: + explicit assign_to_pointee(T* p) : ptr(p) {} + + template + assign_to_pointee& operator=(const Other& other) + { + *ptr = other; + return *this; + } + + private: + T* ptr; + }; + + // Swallows any assignment + struct swallow_assign + { + template + swallow_assign& operator=(const T&) + { + return *this; + } + }; + + } // end of namespace tuples + } // end of namespace detail + + // cons builds a heterogenous list of types + template + struct cons + { + typedef cons self_type; + typedef Head head_type; + typedef Tail tail_type; + + head_type head; + tail_type tail; + + typename boost::add_reference::type get_head() { return head; } + typename boost::add_reference::type get_tail() { return tail; } + + typename boost::add_reference::type get_head() const { return head; } + typename boost::add_reference::type get_tail() const { return tail; } + + template + explicit cons(const Other& other) : head(other.head), tail(other.tail) + { + } + +#if defined BOOST_MSVC + explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf. + const tail_type& t = tail_type()) : + head(h), tail(t) + { + } +#else + explicit cons(const head_type& h = head_type(), + const tail_type& t = tail_type()) : + head(h), tail(t) + { + } +#endif + + + template + cons& operator=(const Other& other) + { + head = other.head; + tail = other.tail; + return *this; + } + }; + + namespace detail { + namespace tuples { + // Determines if the parameter is null_type + template struct is_null_type { enum { RET = 0 }; }; + template<> struct is_null_type { enum { RET = 1 }; }; + + /* Build a cons structure from the given Head and Tail. If both are null_type, + return null_type. */ + template + struct build_cons + { + private: + enum { tail_is_null_type = is_null_type::RET }; + public: + typedef cons RET; + }; + + template<> + struct build_cons + { + typedef null_type RET; + }; + + // Map the N elements of a tuple into a cons list + template< + typename T1, + typename T2 = null_type, + typename T3 = null_type, + typename T4 = null_type, + typename T5 = null_type, + typename T6 = null_type, + typename T7 = null_type, + typename T8 = null_type, + typename T9 = null_type, + typename T10 = null_type + > + struct map_tuple_to_cons + { + typedef typename detail::tuples::build_cons::RET cons10; + typedef typename detail::tuples::build_cons::RET cons9; + typedef typename detail::tuples::build_cons::RET cons8; + typedef typename detail::tuples::build_cons::RET cons7; + typedef typename detail::tuples::build_cons::RET cons6; + typedef typename detail::tuples::build_cons::RET cons5; + typedef typename detail::tuples::build_cons::RET cons4; + typedef typename detail::tuples::build_cons::RET cons3; + typedef typename detail::tuples::build_cons::RET cons2; + typedef typename detail::tuples::build_cons::RET cons1; + }; + + // Workaround the lack of partial specialization in some compilers + template + struct _element_type + { + template + struct inner + { + private: + typedef typename Tuple::tail_type tail_type; + typedef _element_type next_elt_type; + + public: + typedef typename _element_type::template inner::RET RET; + }; + }; + + template<> + struct _element_type<0> + { + template + struct inner + { + typedef typename Tuple::head_type RET; + }; + }; + } // detail + } // tuples + + // Return the Nth type of the given Tuple + template + struct tuple_element + { + private: + typedef detail::tuples::_element_type nth_type; + + public: + typedef typename nth_type::template inner::RET RET; + typedef RET type; + }; + + namespace detail { + namespace tuples { + // Return a reference to the Nth type of the given Tuple + template + struct tuple_element_ref + { + private: + typedef typename tuple_element::RET elt_type; + + public: + typedef typename add_reference::type RET; + typedef RET type; + }; + + // Return a const reference to the Nth type of the given Tuple + template + struct tuple_element_const_ref + { + private: + typedef typename tuple_element::RET elt_type; + + public: + typedef typename add_reference::type RET; + typedef RET type; + }; + } + } + // Get length of this tuple + template + struct tuple_length + { + enum { value = 1 + tuple_length::value }; + }; + + template<> + struct tuple_length + { + enum { value = 0 }; + }; + + // Reference the Nth element in a tuple and retrieve it with "get" + template + struct element + { + template + static inline + typename detail::tuples::tuple_element_ref::RET + get(Tuple& t) + { + return element::get(t.tail); + } + + template + static inline + typename detail::tuples::tuple_element_const_ref::RET + get(const Tuple& t) + { + return element::get(t.tail); + } + }; + + template<> + struct element<0> + { + template + static inline + typename add_reference::type + get(Tuple& t) + { + return t.head; + } + + template + static inline + typename add_reference::type + get(const Tuple& t) + { + return t.head; + } + }; + + // tuple class + template< + typename T1, + typename T2 = null_type, + typename T3 = null_type, + typename T4 = null_type, + typename T5 = null_type, + typename T6 = null_type, + typename T7 = null_type, + typename T8 = null_type, + typename T9 = null_type, + typename T10 = null_type + > + class tuple : + public detail::tuples::map_tuple_to_cons::cons1 + { + private: + typedef detail::tuples::map_tuple_to_cons mapped_tuple; + typedef typename mapped_tuple::cons10 cons10; + typedef typename mapped_tuple::cons9 cons9; + typedef typename mapped_tuple::cons8 cons8; + typedef typename mapped_tuple::cons7 cons7; + typedef typename mapped_tuple::cons6 cons6; + typedef typename mapped_tuple::cons5 cons5; + typedef typename mapped_tuple::cons4 cons4; + typedef typename mapped_tuple::cons3 cons3; + typedef typename mapped_tuple::cons2 cons2; + typedef typename mapped_tuple::cons1 cons1; + + public: + typedef tuple self_type; + + explicit tuple(const T1& t1 = T1(), + const T2& t2 = T2(), + const T3& t3 = T3(), + const T4& t4 = T4(), + const T5& t5 = T5(), + const T6& t6 = T6(), + const T7& t7 = T7(), + const T8& t8 = T8(), + const T9& t9 = T9(), + const T10& t10 = T10()) : + cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10)))))))))) + { + } + + template + explicit tuple(const Other& other) : cons1(other) + { + } + + template + self_type& operator=(const Other& other) + { + this->head = other.head; + this->tail = other.tail; + return *this; + } + }; + + // Retrieve the Nth element in the typle + template + typename detail::tuples::tuple_element_ref::RET + get(Tuple& t) + { + return element::get(t); + } + + // Retrieve the Nth element in the typle + template + typename detail::tuples::tuple_element_const_ref::RET + get(const Tuple& t) + { + return element::get(t); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1) + { + return tuple(t1); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2) + { + return tuple(t1, t2); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3) + { + return tuple(t1, t2, t3); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) + { + return tuple(t1, t2, t3, t4); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) + { + return tuple(t1, t2, t3, t4, t5); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) + { + return tuple(t1, t2, t3, t4, t5, t6); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) + { + return tuple(t1, t2, t3, t4, t5, t6, t7); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) + { + return tuple(t1, t2, t3, t4, t5, t6, t7, t8); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) + { + return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) + { + return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); + } + + // Tie variables into a tuple + template + inline + tuple > + tie(T1& t1) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4), + detail::tuples::assign_to_pointee(&t5)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4), + detail::tuples::assign_to_pointee(&t5), + detail::tuples::assign_to_pointee(&t6)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4), + detail::tuples::assign_to_pointee(&t5), + detail::tuples::assign_to_pointee(&t6), + detail::tuples::assign_to_pointee(&t7)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4), + detail::tuples::assign_to_pointee(&t5), + detail::tuples::assign_to_pointee(&t6), + detail::tuples::assign_to_pointee(&t7), + detail::tuples::assign_to_pointee(&t8)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4), + detail::tuples::assign_to_pointee(&t5), + detail::tuples::assign_to_pointee(&t6), + detail::tuples::assign_to_pointee(&t7), + detail::tuples::assign_to_pointee(&t8), + detail::tuples::assign_to_pointee(&t9)); + } + // Tie variables into a tuple + template + inline + tuple, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee, + detail::tuples::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10) + { + return make_tuple(detail::tuples::assign_to_pointee(&t1), + detail::tuples::assign_to_pointee(&t2), + detail::tuples::assign_to_pointee(&t3), + detail::tuples::assign_to_pointee(&t4), + detail::tuples::assign_to_pointee(&t5), + detail::tuples::assign_to_pointee(&t6), + detail::tuples::assign_to_pointee(&t7), + detail::tuples::assign_to_pointee(&t8), + detail::tuples::assign_to_pointee(&t9), + detail::tuples::assign_to_pointee(&t10)); + } + // "ignore" allows tuple positions to be ignored when using "tie". + namespace { + detail::tuples::swallow_assign ignore; + } + +} // namespace boost +#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP diff --git a/boost/boost/tuple/reference_wrappers.hpp b/boost/boost/tuple/reference_wrappers.hpp new file mode 100644 index 0000000000..52df59f9b9 --- /dev/null +++ b/boost/boost/tuple/reference_wrappers.hpp @@ -0,0 +1,57 @@ +// -- reference_wrappers - Boost Tuple Library ----------------------------- + +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. +// +// For more information, see http://www.boost.org + +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_REFERENCE_WRAPPERS_HPP +#define BOOST_TUPLE_REFERENCE_WRAPPERS_HPP + +namespace boost { + + +// reference wrappers ------------------------------------------------------- + +// These wrappers are handle classes that hold references to objects. + +// reference_wrapper is used to specify that a tuple element should be +// a reference to the wrapped object - rather than a copy of it. +// The wrapper acts as a disguise for passing non-const reference +// parameters via a reference to const parameter. + +template +class reference_wrapper { + T& x; +public: + explicit + reference_wrapper(T& t) : x(t) {} + operator T&() const { return x; } +}; + +// store as a reference to T +template +inline const reference_wrapper ref(T& t) { + return reference_wrapper(t); +} + +// store as a reference to const T +template +inline const reference_wrapper cref(const T& t) { + return reference_wrapper(t); +} + +} // end of namespace boost + + +#endif // BOOST_TUPLE_REFERENCE_WRAPPERS_HPP diff --git a/boost/boost/tuple/tuple.hpp b/boost/boost/tuple/tuple.hpp new file mode 100644 index 0000000000..bd39730dc1 --- /dev/null +++ b/boost/boost/tuple/tuple.hpp @@ -0,0 +1,36 @@ +// tuple.hpp - Boost Tuple Library -------------------------------------- + +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +// For more information, see http://www.boost.org + +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_HPP +#define BOOST_TUPLE_HPP + +#include "boost/config.hpp" +#include "boost/static_assert.hpp" + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// The MSVC version +#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp" + +#else +// other compilers +#include "boost/tuple/reference_wrappers.hpp" +#include "boost/tuple/detail/tuple_basic.hpp" + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + +#endif // BOOST_TUPLE_HPP diff --git a/boost/boost/tuple/tuple_comparison.hpp b/boost/boost/tuple/tuple_comparison.hpp new file mode 100644 index 0000000000..a34d67df7d --- /dev/null +++ b/boost/boost/tuple/tuple_comparison.hpp @@ -0,0 +1,180 @@ +// tuple_comparison.hpp ----------------------------------------------------- +// +// Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. +// +// For more information, see http://www.boost.org +// +// (The idea and first impl. of comparison operators was from Doug Gregor) + +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_COMPARISON_HPP +#define BOOST_TUPLE_COMPARISON_HPP + +#include "boost/tuple/tuple.hpp" + +// ------------------------------------------------------------- +// equality and comparison operators +// +// == and != compare tuples elementwise +// <, >, <= and >= use lexicographical ordering +// +// Any operator between tuples of different length fails at compile time +// No dependencies between operators are assumed +// (i.e. !(a=b, a!=b does not imply a==b etc. +// so any weirdnesses of elementary operators are respected). +// +// ------------------------------------------------------------- + + +namespace boost { + +inline bool operator==(const null_type&, const null_type&) { return true; } +inline bool operator>=(const null_type&, const null_type&) { return true; } +inline bool operator<=(const null_type&, const null_type&) { return true; } +inline bool operator!=(const null_type&, const null_type&) { return false; } +inline bool operator<(const null_type&, const null_type&) { return false; } +inline bool operator>(const null_type&, const null_type&) { return false; } + + +namespace detail { +namespace tuples { + // comparison operators check statically the length of its operands and + // delegate the comparing task to the following functions. Hence + // the static check is only made once (should help the compiler). + // These functions assume tuples to be of the same length. + + +template +inline bool eq(const T1& lhs, const T2& rhs) { + return lhs.get_head() == rhs.get_head() && + eq(lhs.get_tail(), rhs.get_tail()); +} +template<> +inline bool eq(const null_type&, const null_type&) { return true; } + +template +inline bool neq(const T1& lhs, const T2& rhs) { + return lhs.get_head() != rhs.get_head() || + neq(lhs.get_tail(), rhs.get_tail()); +} +template<> +inline bool neq(const null_type&, const null_type&) { return true; } + +template +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()); +} +template<> +inline bool lt(const null_type&, const null_type&) { return false; } + +template +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()); +} +template<> +inline bool gt(const null_type&, const null_type&) { return false; } + +template +inline bool lte(const T1& lhs, const T2& rhs) { + return lhs.get_head() <= rhs.get_head() && + ( !(rhs.get_head() <= lhs.get_head()) || + lte(lhs.get_tail(), rhs.get_tail())); +} +template<> +inline bool lte(const null_type&, const null_type&) { return true; } + +template +inline bool gte(const T1& lhs, const T2& rhs) { + return lhs.get_head() >= rhs.get_head() && + ( !(rhs.get_head() >= lhs.get_head()) || + gte(lhs.get_tail(), rhs.get_tail())); +} +template<> +inline bool gte(const null_type&, const null_type&) { return true; } + +} // end of namespace tuples +} // end of namespace detail + + +// equal ---- + +template +inline bool operator==(const cons& lhs, const cons& rhs) +{ + // check that tuple_lengths are equal + BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); + + return detail::tuples::eq(lhs, rhs); +} + +// not equal ----- + +template +inline bool operator!=(const cons& lhs, const cons& rhs) +{ + + // check that tuple_lengths are equal + BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); + + return detail::tuples::neq(lhs, rhs); +} + +// < +template +inline bool operator<(const cons& lhs, const cons& rhs) +{ + // check that tuple_lengths are equal + BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); + + return detail::tuples::lt(lhs, rhs); +} + +// > +template +inline bool operator>(const cons& lhs, const cons& rhs) +{ + // check that tuple_lengths are equal + BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); + + return detail::tuples::gt(lhs, rhs); +} + +// <= +template +inline bool operator<=(const cons& lhs, const cons& rhs) +{ + // check that tuple_lengths are equal + BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); + + return detail::tuples::lte(lhs, rhs); +} + +// >= +template +inline bool operator>=(const cons& lhs, const cons& rhs) +{ + // check that tuple_lengths are equal + BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); + + return detail::tuples::gte(lhs, rhs); +} + +} // end of namespace boost + + +#endif // BOOST_TUPLE_COMPARISON_HPP diff --git a/boost/boost/tuple/tuple_io.hpp b/boost/boost/tuple/tuple_io.hpp new file mode 100644 index 0000000000..3e8896fe72 --- /dev/null +++ b/boost/boost/tuple/tuple_io.hpp @@ -0,0 +1,501 @@ +// tuple_io.hpp -------------------------------------------------------------- + +// Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// 2001 Gary Powell (gary.powell@sierra.com) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. +// For more information, see http://www.boost.org + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_TUPLE_IO_HPP +#define BOOST_TUPLE_IO_HPP + + +// add to boost/config.hpp +// for now +# if defined __GNUC__ +# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) +#define BOOST_NO_TEMPLATED_STREAMS +#endif +#endif // __GNUC__ + +#if defined BOOST_NO_TEMPLATED_STREAMS +#include +#else +#include +#include +#endif + +#include "boost/tuple/tuple.hpp" + + + +namespace boost { + +namespace detail { +namespace tuples { + +class format_info { +public: + enum manipulator_type { open, close, delimiter }; + BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1); +private: + + static const int stream_index[number_of_manipulators]; + format_info(const format_info&); + format_info(); + + +public: + +#if defined (BOOST_NO_TEMPLATED_STREAMS) + static char get_manipulator(std::ios& i, manipulator_type m) { + char c = static_cast(i.iword(stream_index[m])); + + // parentheses and space are the default manipulators + if (!c) { + switch(m) { + case open : c = '('; break; + case close : c = ')'; break; + case delimiter : c = ' '; break; + } + } + return c; + } + + static void set_manipulator(std::ios& i, manipulator_type m, char c) { + i.iword(stream_index[m]) = static_cast(c); + } +#else + template + static CharType get_manipulator(std::basic_ios& i, + manipulator_type m) { + // The manipulators are stored as long. + // A valid instanitation of basic_stream allows CharType to be any POD, + // hence, the static_cast may fail (it fails if long is not convertible + // to CharType + CharType c = static_cast(i.iword(stream_index[m]) ); + // parentheses and space are the default manipulators + if (!c) { + switch(m) { + case open : c = i.widen('('); break; + case close : c = i.widen(')'); break; + case delimiter : c = i.widen(' '); break; + } + } + return c; + } + + + template + static void set_manipulator(std::basic_ios& i, + manipulator_type m, CharType c) { + // The manipulators are stored as long. + // A valid instanitation of basic_stream allows CharType to be any POD, + // hence, the static_cast may fail (it fails if CharType is not + // convertible long. + i.iword(stream_index[m]) = static_cast(c); + } +#endif // BOOST_NO_TEMPLATED_STREAMS +}; + +template +class tuple_manipulator { + const format_info::manipulator_type mt; + CharType f_c; +public: + explicit tuple_manipulator(format_info::manipulator_type m, const char c = 0) + : mt(m), f_c(c) {} + +#if defined (BOOST_NO_TEMPLATED_STREAMS) + void set(std::ios &io) const { + format_info::set_manipulator(io, mt, f_c); + } +#else +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + template + void set(std::basic_ios &io) const { + format_info::set_manipulator(io, mt, f_c); + } +#else + template + void set(std::basic_ios &io) const { + format_info::set_manipulator(io, mt, f_c); + } +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#endif // BOOST_NO_TEMPLATED_STREAMS +}; + +} // end of namespace tuples +} // end of namespace detail + + +#if defined (BOOST_NO_TEMPLATED_STREAMS) +inline std::ostream& +operator<<(std::ostream& o, const detail::tuples::tuple_manipulator& m) { + m.set(o); + return o; +} + +inline std::istream& +operator>>(std::istream& i, const detail::tuples::tuple_manipulator& m) { + m.set(i); + return i; +} + +#else + +template +inline std::basic_ostream& +operator<<(std::basic_ostream& o, const detail::tuples::tuple_manipulator& m) { + m.set(o); + return o; +} + +template +inline std::basic_istream& +operator>>(std::basic_istream& i, const detail::tuples::tuple_manipulator& m) { + m.set(i); + return i; +} + +#endif // BOOST_NO_TEMPLATED_STREAMS + +template +inline detail::tuples::tuple_manipulator set_open(const CharType c) { + return detail::tuples::tuple_manipulator(detail::tuples::format_info::open, c); +} + +template +inline detail::tuples::tuple_manipulator set_close(const CharType c) { + return detail::tuples::tuple_manipulator(detail::tuples::format_info::close, c); +} + +template +inline detail::tuples::tuple_manipulator set_delimiter(const CharType c) { + return detail::tuples::tuple_manipulator(detail::tuples::format_info::delimiter, c); +} + + + + + +// ------------------------------------------------------------- +// printing tuples to ostream in format (a b c) +// parentheses and space are defaults, but can be overriden with manipulators +// set_open, set_close and set_delimiter + +namespace detail { +namespace tuples { + +// Note: The order of the print functions is critical +// to let a conforming compiler find and select the correct one. + +#if defined (BOOST_NO_TEMPLATED_STREAMS) + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template +inline std::ostream& print(std::ostream& o, const cons& t) { + return o << t.head; +} +#endif // BOOST_NO_TEMPLATED_STREAMS + +inline std::ostream& print(std::ostream& o, const null_type&) { return o; } + +template +inline std::ostream& +print(std::ostream& o, const cons& t) { + + const char d = format_info::get_manipulator(o, format_info::delimiter); + + o << t.head; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + if (tuple_length::value == 0) + return o; +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + o << d; + + return print(o, t.tail ); + +} + + + +#else + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template +inline std::basic_ostream& +print(std::basic_ostream& o, const cons& t) { + return o << t.head; +} +#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + +template +inline std::basic_ostream& +print(std::basic_ostream& o, const null_type&) { + return o; +} + +template +inline std::basic_ostream& +print(std::basic_ostream& o, const cons& t) { + + const CharType d = format_info::get_manipulator(o, format_info::delimiter); + + o << t.head; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + if (tuple_length::value == 0) + return o; +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + o << d; + + return print(o, t.tail); +} + +#endif // BOOST_NO_TEMPLATED_STREAMS + +} // namespace tuples +} // namespace detail + +#if defined (BOOST_NO_TEMPLATED_STREAMS) +template +inline std::ostream& operator<<(std::ostream& o, const cons& t) { + if (!o.good() ) return o; + + const char l = + detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open); + const char r = + detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close); + + o << l; + + detail::tuples::print(o, t); + + o << r; + + return o; +} + +#else + +template +inline std::basic_ostream& +operator<<(std::basic_ostream& o, + const cons& t) { + if (!o.good() ) return o; + + const CharType l = + detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open); + const CharType r = + detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close); + + o << l; + + detail::tuples::print(o, t); + + o << r; + + return o; +} +#endif // BOOST_NO_TEMPLATED_STREAMS + + +// ------------------------------------------------------------- +// input stream operators + +namespace detail { +namespace tuples { + +#if defined (BOOST_NO_TEMPLATED_STREAMS) + +inline std::istream& +extract_and_check_delimiter( + std::istream& is, format_info::manipulator_type del) +{ + const char d = format_info::get_manipulator(is, del); + + const bool is_delimiter = (!isspace(d) ); + + char c; + if (is_delimiter) { + is >> c; + if (c!=d) { + is.setstate(std::ios::failbit); + } + } + return is; +} + + +// Note: The order of the read functions is critical to let a +// (conforming?) compiler find and select the correct one. + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template +inline std::istream & +read (std::istream &is, cons& t1) { + + if (!is.good()) return is; + + return is >> t1.head ; +} +#else +inline std::istream& read(std::istream& i, const null_type&) { return i; } +#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template +inline std::istream& +read(std::istream &is, cons& t1) { + + if (!is.good()) return is; + + is >> t1.head; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + if (tuple_length::value == 0) + return is; +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + extract_and_check_delimiter(is, format_info::delimiter); + + return read(is, t1.tail); +} + +} // end namespace tuples +} // end namespace detail + +inline std::istream& +operator>>(std::istream &is, null_type&) { + + if (!is.good() ) return is; + + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); + + return is; +} + + +template +inline std::istream& +operator>>(std::istream& is, cons& t1) { + + if (!is.good() ) return is; + + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); + + detail::tuples::read(is, t1); + + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); + + return is; +} + + + +#else + +template +inline std::basic_istream& +extract_and_check_delimiter( + std::basic_istream &is, format_info::manipulator_type del) +{ + const CharType d = format_info::get_manipulator(is, del); + + const bool is_delimiter = (!isspace(d) ); + + CharType c; + if (is_delimiter) { + is >> c; + if (c!=d) { + is.setstate(std::ios::failbit); + } + } + return is; +} + + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template +inline std::basic_istream & +read (std::basic_istream &is, cons& t1) { + + if (!is.good()) return is; + + return is >> t1.head; +} +#else +template +inline std::basic_istream& +read(std::basic_istream& i, const null_type&) { return i; } + +#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template +inline std::basic_istream& +read(std::basic_istream &is, cons& t1) { + + if (!is.good()) return is; + + is >> t1.head; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + if (tuple_length::value == 0) + return is; +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + extract_and_check_delimiter(is, format_info::delimiter); + + return read(is, t1.tail); +} + +} // end namespace tuples +} // end namespace detail + + +template +inline std::basic_istream& +operator>>(std::basic_istream &is, null_type&) { + + if (!is.good() ) return is; + + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); + + return is; +} + +template +inline std::basic_istream& +operator>>(std::basic_istream& is, cons& t1) { + + if (!is.good() ) return is; + + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); + + detail::tuples::read(is, t1); + + detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); + + return is; +} + +#endif // BOOST_NO_TEMPLATED_STREAMS + +} // end of namespace boost + +#endif // BOOST_TUPLE_IO_HPP + + diff --git a/boost/boost/type_traits/alignment_traits.hpp b/boost/boost/type_traits/alignment_traits.hpp new file mode 100644 index 0000000000..52af79a8fd --- /dev/null +++ b/boost/boost/type_traits/alignment_traits.hpp @@ -0,0 +1,84 @@ + +// (C) Copyright John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. + +// +// defines alignment_of: + +#ifndef ALIGNMENT_TYPE_TRAITS_HPP +#define ALIGNMENT_TYPE_TRAITS_HPP + +#include +#include +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif + +namespace boost{ +// +// get the alignment of some arbitrary type: +namespace detail{ + +template +struct alignment_of_hack +{ + char c; + T t; + alignment_of_hack(); +}; + +template +struct alignment_logic +{ + BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S); +}; + +} // namespace detail + +template +struct alignment_of +{ + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(detail::alignment_of_hack) - sizeof(T), + sizeof(T) + >::value)); +}; + +// +// references have to be treated specially, assume +// that a reference is just a special pointer: +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct alignment_of +{ +public: + BOOST_STATIC_CONSTANT(std::size_t, value = alignment_of::value); +}; +#endif +// +// void has to be treated specially: +template <> +struct alignment_of +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct alignment_of +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +template <> +struct alignment_of +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +template <> +struct alignment_of +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +#endif + +} // namespace boost + +#endif // ALIGNMENT_TYPE_TRAITS_HPP + + + diff --git a/boost/boost/type_traits/arithmetic_traits.hpp b/boost/boost/type_traits/arithmetic_traits.hpp new file mode 100644 index 0000000000..bccac51247 --- /dev/null +++ b/boost/boost/type_traits/arithmetic_traits.hpp @@ -0,0 +1,270 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for arithmetic types: +// is_void, is_integral, is_float, is_arithmetic, is_fundamental. +// + +// Revision History: +// Feb 19 2001 Added #include (David Abrahams) + +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +#define BOOST_ARITHMETIC_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif + +#include // for ULLONG_MAX/ULONG_LONG_MAX + +namespace boost{ + +//* is a type T void - is_void +template struct is_void{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_void{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +//* 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 +template struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<__int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +//* is a type T a floating-point type described in the standard (3.9.1p8) +template struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +// +// declare cv-qualified specialisations of these templates only +// if BOOST_NO_CV_SPECIALIZATIONS is not defined: +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_void +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_void +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_void +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#ifndef BOOST_NO_CV_SPECIALIZATIONS +// const-variations: +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif // ULLONG_MAX +#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif //__int64 + +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +// volatile-variations: +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif // ULLONG_MAX +#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif //__int64 + +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +// const-volatile-variations: +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif // ULLONG_MAX +#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__) +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif //__int64 + +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +#endif // BOOST_NO_CV_SPECIALIZATIONS + +//* is a type T an arithmetic type described in the standard (3.9.1p8) +template +struct is_arithmetic +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_integral::value, + ::boost::is_float::value + >::value)); +}; + +//* is a type T a fundamental type described in the standard (3.9.1) +template +struct is_fundamental +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value, + ::boost::is_void::value + >::value)); +}; + +} // namespace boost + +#endif + + + + + + + diff --git a/boost/boost/type_traits/composite_traits.hpp b/boost/boost/type_traits/composite_traits.hpp new file mode 100644 index 0000000000..b3df3007f4 --- /dev/null +++ b/boost/boost/type_traits/composite_traits.hpp @@ -0,0 +1,537 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for composite types: +// is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union. +// +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). +// Fixes for is_array are based on a newgroup posting by Jonathan Lundquist. + +// +// Revision History: +// 21st March 2001: +// Fixed is_enum so that it works with incomplete types. + +#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP +#define BOOST_COMPOSITE_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_CV_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_TRANSFORM_TRAITS_HPP +#include +#endif + +namespace boost{ + +/********************************************** + * + * is_array + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template struct is_array +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_array +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_array +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_array +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_array +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail{ + struct pointer_helper + { + pointer_helper(const volatile void*); + }; + yes_type is_pointer_helper(pointer_helper); + no_type is_pointer_helper(...); + +::boost::type_traits::no_type is_function_tester(...); +template +::boost::type_traits::yes_type is_function_tester(R (*)(void)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28)); +template +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29)); + + + yes_type is_array_helper(const volatile void*, const volatile void*); + template + no_type is_array_helper(T*const volatile*, const volatile void*); + no_type is_array_helper(...); +} // namespace detail +template +struct is_array +{ +private: + static T t; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + (1 == sizeof(detail::is_array_helper(&t, t))), + ::boost::type_traits::ice_not< + ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< + (1 == sizeof(detail::is_function_tester(t)))>::value + >::value)); +}; +template <> +struct is_array +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct is_array +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_array +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_array +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#endif + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +/********************************************** + * + * is_pointer + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail{ +template struct is_pointer_helper +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_pointer_helper +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_pointer_helper +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_pointer_helper +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_pointer_helper +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +} // namespace detail +template struct is_pointer +{ BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper::value, ::boost::type_traits::ice_not< ::boost::is_member_pointer::value >::value >::value)); }; +#else +template +struct is_pointer +{ +private: + static T t; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< + ::boost::is_reference::value + >::value, + ::boost::type_traits::ice_not< + ::boost::is_array::value + >::value, + (::boost::type_traits::ice_or< + (1 == sizeof(detail::is_pointer_helper(t))), + (1 == sizeof(detail::is_function_tester(t))) + >::value) + >::value ) ); +}; +template <> +struct is_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct is_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#endif +#endif + +/********************************************** + * + * is_reference + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#if defined(__BORLANDC__) +// 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 +// references as distinct types... +template struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#else +# ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4181) +#endif // BOOST_MSVC +template struct is_reference +{ +private: + typedef T const volatile cv_t; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::type_traits::ice_not< + ::boost::is_const::value + >::value, + ::boost::type_traits::ice_not< + ::boost::is_volatile::value>::value + >::value)); +}; +template <> struct is_reference +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_reference +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#endif + +# ifdef BOOST_MSVC +# pragma warning(pop) +# endif // BOOST_MSVC +#endif + +/********************************************** + * + * is_union + * + **********************************************/ +template struct is_union +{ +private: + typedef typename remove_cv::type cvt; +public: + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(cvt)); +}; + +/********************************************** + * + * is_enum + * + **********************************************/ +namespace detail{ +struct int_convertible +{ + int_convertible(int); +}; +} // namespace detail +#ifndef __BORLANDC__ +template struct is_enum +{ +private: + typedef typename ::boost::add_reference::type r_type; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_arithmetic::value>::value, + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::is_convertible::value + >::value)); +}; +#else // __BORLANDC__ +// +// buggy is_convertible prevents working +// implementation of is_enum: +template struct is_enum +{ +public: + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_ENUM(T)); +}; +#endif + +/********************************************** + * + * is_member_pointer + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template struct is_member_pointer +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_member_pointer +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifdef __GNUC__ +// gcc workaround (JM 02 Oct 2000) +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_member_pointer{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#else +namespace detail{ +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(void)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28)); +template +::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29)); + no_type is_member_pointer_helper(...); +} +template +struct is_member_pointer +{ +private: + static T t; +public: + BOOST_STATIC_CONSTANT(bool, value = (1 == sizeof(detail::is_member_pointer_helper(t))) ); +}; +template <> +struct is_member_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct is_member_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_member_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_member_pointer +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#endif + +#endif + + +} // namespace boost + +#endif // BOOST_COMPOSITE_TYPE_TRAITS_HPP + + + + + diff --git a/boost/boost/type_traits/conversion_traits.hpp b/boost/boost/type_traits/conversion_traits.hpp new file mode 100644 index 0000000000..aceeec4c22 --- /dev/null +++ b/boost/boost/type_traits/conversion_traits.hpp @@ -0,0 +1,229 @@ + +// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com) +// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu) +// Copyright (C) 1999, 2000 Jaakko J„rvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy and use this software is granted, +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted, +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. +// + +#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP +#define BOOST_CONVERSION_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +#include +#endif +// +// is one type convertable to another? +// +// there are multiple versions of the is_convertible +// template, almost every compiler seems to require its +// own version. +// +// Thanks to Andrei Alexandrescu for the original version of the +// conversion detection technique! +// + +namespace boost{ + +#ifdef BOOST_MSVC + +// +// MS specific version: +// +namespace detail{ + + // This workaround is necessary to handle when From is void + // which is normally taken care of by the partial specialization + // of the is_convertible class. + using ::boost::type_traits::yes_type; + using ::boost::type_traits::no_type; + + struct from_not_void_conversion { + template + struct n_bind { + static no_type _m_check(...); + static yes_type _m_check(To); + public: + void foo(); // avoid warning about all members being private + static From _m_from; + enum { exists = sizeof( _m_check(_m_from) ) == sizeof(yes_type) }; + }; + }; + struct from_is_void_conversion { + template + struct n_bind { + enum { exists = ::boost::is_void::value }; + }; + }; + + template + struct conversion_helper { + typedef from_not_void_conversion type; + }; + template <> + struct conversion_helper { + typedef from_is_void_conversion type; + }; +} // namespace detail + +template +struct is_convertible +{ + typedef typename detail::conversion_helper::type Selector; + typedef Selector::template n_bind Conversion; +public: + enum { value = Conversion::exists }; +}; + +#elif defined(__BORLANDC__) +// +// special version for Borland compilers +// this version breaks when used for some +// UDT conversions: +// +template +struct is_convertible_helper +{ +private: + // This workaround for Borland breaks the EDG C++ frontend, + // so we only use it for Borland. + template + struct checker + { + static type_traits::no_type _m_check(...); + static type_traits::yes_type _m_check(T); + }; + static From _m_from; +public: + static const bool value = sizeof( checker::_m_check(_m_from) ) == sizeof(type_traits::yes_type); + + void foo(); // avoid warning about all members being private +}; + +template +struct is_convertible +{ +private: + typedef is_convertible_helper c_type; + enum{ v = c_type::value }; + char force_it[v ? 1 : 2]; +public: + static const bool value = is_convertible_helper::value; +}; + +template +struct is_convertible +{ + static const bool value = false; +}; +template +struct is_convertible +{ + static const bool value = false; +}; +template <> +struct is_convertible +{ + static const bool value = true; +}; + +#elif defined(__GNUC__) +// +// special version for gcc compiler +// +namespace detail{ + struct any_conversion + { + template + any_conversion(const T&); + template + any_conversion(T&); + }; + template + struct checker + { + static boost::type_traits::no_type _m_check(any_conversion ...); + static boost::type_traits::yes_type _m_check(T, int); + }; +} // namespace detail +template +struct is_convertible +{ +private: + static From _m_from; +public: + static const bool value = sizeof( detail::checker::_m_check(_m_from, 0) ) == sizeof(type_traits::yes_type); + + void foo(); // avoid warning about all members being private +}; + +template +struct is_convertible +{ + static const bool value = false; +}; +template +struct is_convertible +{ + static const bool value = false; +}; +template <> +struct is_convertible +{ + static const bool value = true; +}; + +#else + +template +struct is_convertible +{ +private: + static type_traits::no_type _m_check(...); + static type_traits::yes_type _m_check(To); + static From _m_from; +public: + BOOST_STATIC_CONSTANT(bool, value = sizeof( _m_check(_m_from) ) == sizeof(type_traits::yes_type)); + void foo(); // avoid warning about all members being private +}; + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct is_convertible +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_convertible +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template <> +struct is_convertible +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // is_convertible + +} // namespace boost + +#endif // include guard + + diff --git a/boost/boost/type_traits/cv_traits.hpp b/boost/boost/type_traits/cv_traits.hpp new file mode 100644 index 0000000000..587882817d --- /dev/null +++ b/boost/boost/type_traits/cv_traits.hpp @@ -0,0 +1,279 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for cv-qualified types: +// is_const, is_volatile, remove_const, remove_volatile, remove_cv. +// +// Revision History: +// 24th March 2001: +// Fixed is_const/is_volatile so that they work with reference types + +#ifndef BOOST_CV_TYPE_TRAITS_HPP +#define BOOST_CV_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif + +namespace boost{ + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail{ +// +// implementation helper: +// +template +struct cv_traits_imp{}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type; +}; + +template +struct remove_const_helper +{ + typedef T type; +}; +template +struct remove_const_helper +{ + typedef volatile T type; +}; + +template +struct remove_volatile_helper +{ + typedef T type; +}; +template +struct remove_volatile_helper +{ + typedef const T type; +}; + +} // namespace detail + +// * convert a type T to a non-volatile type - remove_volatile +template +struct remove_volatile +{ + typedef typename detail::cv_traits_imp::unqualified_type uq_type; + typedef typename detail::remove_volatile_helper::value>::type type; +}; +template struct remove_volatile{ typedef T& type; }; +template struct remove_volatile{ typedef T type[N]; }; +template struct remove_volatile{ typedef const T type[N]; }; + +// * convert a type T to non-const type - remove_const +template +struct remove_const +{ + typedef typename detail::cv_traits_imp::unqualified_type uq_type; + typedef typename detail::remove_const_helper::value>::type type; +}; +template struct remove_const{ typedef T& type; }; +template struct remove_const{ typedef T type[N]; }; +template struct remove_const{ typedef volatile T type[N]; }; + +// convert a type T to a non-cv-qualified type - remove_cv +template +struct remove_cv +{ + typedef typename detail::cv_traits_imp::unqualified_type type; +}; +template struct remove_cv{ typedef T& type; }; +template struct remove_cv{ typedef T type[N]; }; +template struct remove_cv{ typedef T type[N]; }; +template struct remove_cv{ typedef T type[N]; }; + +//* is a type T declared const - is_const +template +struct is_const +{ + BOOST_STATIC_CONSTANT(bool, value = detail::cv_traits_imp::is_const); +}; +template struct is_const +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#if defined(__BORLANDC__) +// 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 +// references as distinct types... +template struct is_const +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_const +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_const +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#endif + +//* is a type T declared volatile - is_volatile +template +struct is_volatile +{ + BOOST_STATIC_CONSTANT(bool, value = detail::cv_traits_imp::is_volatile); +}; +template struct is_volatile +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#if defined(__BORLANDC__) +// 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 +// references as distinct types... +template struct is_volatile +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_volatile +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template struct is_volatile +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#endif + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +// The following three don't work: +template struct remove_volatile{ typedef T type; }; +template struct remove_const{ typedef T type; }; +template struct remove_cv{ typedef T type; }; + +namespace detail{ + using ::boost::type_traits::yes_type; + using ::boost::type_traits::no_type; + yes_type is_const_helper(const volatile void*); + no_type is_const_helper(volatile void *); + yes_type is_volatile_helper(const volatile void*); + no_type is_volatile_helper(const void *); +} + +template +struct is_const +{ +private: + static T t; +public: + BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_const_helper(&t)))); +}; + +template <> +struct is_const +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct is_const +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <> +struct is_const +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_const +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; +#endif + +template +struct is_volatile +{ +private: + static T t; +public: + BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_volatile_helper(&t)))); +}; + +template <> +struct is_volatile +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct is_volatile +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_volatile +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <> +struct is_volatile +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; +#endif + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// * convert a type T to const type - add_const +// this is not required since the result is always +// the same as "T const", but it does suppress warnings +// from some compilers: +template +struct add_const +{ + typedef T const type; +}; +// * convert a type T to volatile type - add_volatile +// this is not required since the result is always +// the same as "T volatile", but it does suppress warnings +// from some compilers: +template +struct add_volatile +{ + typedef T volatile type; +}; +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct add_const{ typedef T& type; }; +template +struct add_volatile{ typedef T& type; }; +#endif + +} // namespace boost + + +#endif // BOOST_CV_TYPE_TRAITS_HPP + + + diff --git a/boost/boost/type_traits/function_traits.hpp b/boost/boost/type_traits/function_traits.hpp new file mode 100644 index 0000000000..b336c789cc --- /dev/null +++ b/boost/boost/type_traits/function_traits.hpp @@ -0,0 +1,148 @@ + +// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com) +// +// Permission to copy and use this software is granted, +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted, +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#ifndef BOOST_FUNCTION_TYPE_TRAITS_HPP +#define BOOST_FUNCTION_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP +#include +#endif +// +// is a type a function? +// +namespace boost{ +namespace detail{ + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_function_helper : is_function_helper_base{}; + +#else + +template +struct is_function_helper +{ + static T* t; + BOOST_STATIC_CONSTANT(bool, value = sizeof(is_function_tester(t)) == sizeof(::boost::type_traits::yes_type)); +}; + +#endif + +template +struct is_function_ref_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template +struct is_function_chooser +{ + typedef is_function_helper type; +}; +template +struct is_function_chooser +{ + typedef is_function_ref_helper type; +}; +#endif +} // namespace detail + +template +struct is_function +{ +private: +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + typedef typename detail::is_function_chooser::value>::type m_type; +#else + // without partial specialistaion we can't use is_reference on + // function types, that leaves this template broken in the case that + // T is a reference: + typedef detail::is_function_helper m_type; +#endif +public: + BOOST_STATIC_CONSTANT(bool, value = m_type::value); +}; + +} // boost + +#endif // BOOST_FUNCTION_TYPE_TRAITS_HPP diff --git a/boost/boost/type_traits/fwd.hpp b/boost/boost/type_traits/fwd.hpp new file mode 100644 index 0000000000..660fdf9e37 --- /dev/null +++ b/boost/boost/type_traits/fwd.hpp @@ -0,0 +1,141 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// forward declarations of type_traits classes +// +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#define BOOST_FWD_TYPE_TRAITS_HPP + +#include +#include + +#ifndef BOOST_CONFIG_HPP +#include +#endif + +// +// Helper macros for builtin compiler support. +// If your compiler has builtin support for any of the following +// traits concepts, then redefine the appropriate macros to pick +// up on the compiler support: +// +// (these should largely ignore cv-qualifiers) +// BOOST_IS_CLASS(T) should evaluate to true if T is a class or struct type +// BOOST_IS_ENUM(T) should evaluate to true if T is an enumerator type +// BOOST_IS_UNION(T) should evaluate to true if T is a union type +// BOOST_IS_POD(T) should evaluate to true if T is a POD type +// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union +// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect +// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy +// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy +// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect + +#define BOOST_IS_CLASS(T) false +#define BOOST_IS_ENUM(T) false +#define BOOST_IS_UNION(T) false +#define BOOST_IS_POD(T) false +#define BOOST_IS_EMPTY(T) false +#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false +#define BOOST_HAS_TRIVIAL_COPY(T) false +#define BOOST_HAS_TRIVIAL_ASSIGN(T) false +#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false + + +namespace boost{ +// +// forward declare all type traits templates here +// +// conversion_traits.hpp: +template +struct is_convertible; +// alignment_traits.hpp: +template +struct alignment_of; +// arithmetic_traits.hpp: +template +struct is_void; +template +struct is_integral; +template +struct is_float; +template +struct is_arithmetic; +template +struct is_fundamental; + +// cv_traits.hpp: +template +struct is_const; +template +struct is_volatile; +template +struct remove_const; +template +struct remove_volatile; +template +struct remove_cv; + +// composite_traits.hpp: +template +struct is_array; +template +struct is_pointer; +template +struct is_reference; +template +struct is_member_pointer; +template +struct is_enum; +template +struct is_union; + +// object_traits.hpp: +template +struct is_object; +template +struct is_scalar; +template +struct is_class; +template +struct is_compound; +template +struct is_POD; +template +struct has_trivial_constructor; +template +struct has_trivial_copy; +template +struct has_trivial_assign; +template +struct has_trivial_destructor; +template +struct is_empty; + +// transform_traits.hpp: +template +struct remove_reference; +template +struct add_reference; +template +struct remove_bounds; +template +struct remove_pointer; +template +struct add_pointer; + +// same_traits.hpp: +template +struct is_same; + +} // namespace boost + +#endif // BOOST_FWD_TYPE_TRAITS_HPP + + + + diff --git a/boost/boost/type_traits/ice.hpp b/boost/boost/type_traits/ice.hpp new file mode 100644 index 0000000000..36e0e2ecc5 --- /dev/null +++ b/boost/boost/type_traits/ice.hpp @@ -0,0 +1,87 @@ + +// (C) Copyright John Maddock and Steve Cleary 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. + +// See http://www.boost.org for most recent version including documentation. +// +// macros and helpers for working with integral-constant-expressions. + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#define BOOST_ICE_TYPE_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +#include +#endif + + +namespace boost{ +namespace type_traits{ + +typedef char yes_type; +typedef double no_type; + +template +struct ice_not +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> +struct ice_not +{ BOOST_STATIC_CONSTANT(bool, value = false); }; + +template +struct ice_or; +template +struct ice_or +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <> +struct ice_or +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct ice_and; +template +struct ice_and +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct ice_and +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template +struct ice_eq +{ + BOOST_STATIC_CONSTANT(bool, value = (b1 == b2)); +}; + +template +struct ice_ne +{ + BOOST_STATIC_CONSTANT(bool, value = (b1 != b2)); +}; + +#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +template +const bool ice_eq::value; +template +const bool ice_ne::value; +#endif + +} // namespace type_traits + +} // namespace boost + +#endif // BOOST_ICE_TYPE_TRAITS_HPP + + + + + diff --git a/boost/boost/type_traits/object_traits.hpp b/boost/boost/type_traits/object_traits.hpp new file mode 100644 index 0000000000..36e2ad921e --- /dev/null +++ b/boost/boost/type_traits/object_traits.hpp @@ -0,0 +1,350 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines object traits classes: +// is_object, is_scalar, is_class, is_compound, is_POD, +// has_trivial_constructor, has_trivial_copy, has_trivial_assign, +// has_trivial_destructor, is_empty. +// + +#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP +#define BOOST_OBJECT_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FUNCTION_TYPE_TRAITS_HPP +#include +#endif + +namespace boost{ + +/********************************************** + * + * is_object + * + **********************************************/ +template +struct is_object +{ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value>::value, + ::boost::type_traits::ice_not< ::boost::is_function::value>::value + >::value)); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value>::value + >::value)); +#endif +}; + +/********************************************** + * + * is_scalar + * + **********************************************/ +template +struct is_scalar +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value, + ::boost::is_enum::value, + ::boost::is_pointer::value, + ::boost::is_member_pointer::value + >::value)); +}; + +/********************************************** + * + * is_class + * + **********************************************/ +template +struct is_class +{ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_union::value >::value, + ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value, + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value >::value, + ::boost::type_traits::ice_not< ::boost::is_function::value >::value + >::value)); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_union::value >::value, + ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value, + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value >::value + >::value)); +#endif +}; + +/********************************************** + * + * is_compound + * + **********************************************/ +template struct is_compound +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_array::value, + ::boost::is_pointer::value, + ::boost::is_reference::value, + ::boost::is_class::value, + ::boost::is_union::value, + ::boost::is_enum::value, + ::boost::is_member_pointer::value + >::value)); +}; + +/********************************************** + * + * is_POD + * + **********************************************/ +template struct is_POD +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_scalar::value, + ::boost::is_void::value, + BOOST_IS_POD(T) + >::value)); +}; +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct is_POD +{ + BOOST_STATIC_CONSTANT(bool, value = ::boost::is_POD::value); +}; +#endif + +/********************************************** + * + * has_trivial_constructor + * + **********************************************/ +template +struct has_trivial_constructor +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_POD::value, + BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) + >::value)); +}; + +/********************************************** + * + * has_trivial_copy + * + **********************************************/ +template +struct has_trivial_copy +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::is_POD::value, + BOOST_HAS_TRIVIAL_COPY(T) + >::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +}; + +/********************************************** + * + * has_trivial_assign + * + **********************************************/ +template +struct has_trivial_assign +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::is_POD::value, + BOOST_HAS_TRIVIAL_ASSIGN(T) + >::value, + ::boost::type_traits::ice_not< ::boost::is_const::value >::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +}; + +/********************************************** + * + * has_trivial_destructor + * + **********************************************/ +template +struct has_trivial_destructor +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_POD::value, + BOOST_HAS_TRIVIAL_DESTRUCTOR(T) + >::value)); +}; + +/********************************************** + * + * is_empty + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail{ + +template +struct empty_helper_t1 : public T +{ +#ifdef __MWERKS__ + empty_helper_t1(); // hh compiler bug workaround +#endif + int i[256]; +}; +struct empty_helper_t2 { int i[256]; }; + +template +struct empty_helper{ BOOST_STATIC_CONSTANT(bool, value = false); }; + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = + (sizeof(empty_helper_t1) == sizeof(empty_helper_t2))); +}; +} + +template +struct is_empty +{ +private: + typedef typename remove_cv::type cvt; + typedef typename add_reference::type r_type; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::detail::empty_helper::value , + ::boost::is_convertible< r_type,int>::value + >::value, + BOOST_IS_EMPTY(cvt) + >::value)); +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES) + +namespace detail{ + +template +struct empty_helper_t1 : public T +{ + int i[256]; +}; +struct empty_helper_t2 { int i[256]; }; + +template +struct empty_helper_base +{ + enum{ value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) }; +}; + +template +struct empty_helper_nonbase +{ + enum{ value = false }; +}; + +template +struct empty_helper_chooser +{ + template + struct rebind + { + typedef empty_helper_nonbase type; + }; +}; + +template <> +struct empty_helper_chooser +{ + template + struct rebind + { + typedef empty_helper_base type; + }; +}; + +} // namespace detail + +template +struct is_empty +{ +private: + typedef ::boost::detail::empty_helper_chooser< + ::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< + ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< + ::boost::is_convertible::value>::value, + ::boost::type_traits::ice_not< + ::boost::is_pointer::value>::value, + ::boost::type_traits::ice_not< + ::boost::is_member_pointer::value>::value, + ::boost::type_traits::ice_not< + ::boost::is_array::value>::value, + ::boost::type_traits::ice_not< + ::boost::is_void::value>::value, + ::boost::type_traits::ice_not< + ::boost::is_convertible::value>::value + >::value> chooser; + typedef typename chooser::template rebind bound_type; + typedef typename bound_type::type eh_type; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or::value)); +}; + +#else +template struct is_empty +{ enum{ value = BOOST_IS_EMPTY(T) }; }; +#endif // defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#endif // BOOST_OBJECT_TYPE_TRAITS_HPP + + + + + + diff --git a/boost/boost/type_traits/same_traits.hpp b/boost/boost/type_traits/same_traits.hpp new file mode 100644 index 0000000000..5c9fef1dde --- /dev/null +++ b/boost/boost/type_traits/same_traits.hpp @@ -0,0 +1,99 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines is_same: + +// Revision History +// 19 Feb 2001 Fixed for MSVC (David Abrahams) + +#ifndef BOOST_SAME_TRAITS_HPP +#define BOOST_SAME_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif +#if !defined(BOOST_COMPOSITE_TYPE_TRAITS_HPP) && defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC) +#include +#endif + +namespace boost{ + +/********************************************** + * + * is_same + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template +struct is_same +{ BOOST_STATIC_CONSTANT(bool, value = false); }; + +template +struct is_same +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#ifdef BOOST_MSVC +// +// the following VC6 specific implementation is *NOT* legal +// C++, but has the advantage that it works for incomplete +// types. +// +namespace detail{ + +template +struct is_same_part_1 { + template struct part_2 { enum { value = false }; }; + template<> struct part_2 { enum { value = true }; }; +}; + +} // namespace detail + +template +struct is_same { + enum { value = detail::is_same_part_1::template part_2::value }; +}; + +#else // BOOST_MSVC + +namespace detail{ + template + ::boost::type_traits::yes_type is_same_helper(T*, T*); + ::boost::type_traits::no_type is_same_helper(...); +} + +template +struct is_same +{ +private: + static T t; + static U u; +public: + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + (sizeof(type_traits::yes_type) == sizeof(detail::is_same_helper(&t,&u))), + (::boost::is_reference::value == ::boost::is_reference::value), + (sizeof(T) == sizeof(U)) + >::value)); +}; + +#endif // BOOST_MSVC + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#endif // BOOST_SAME_TRAITS_HPP + + + diff --git a/boost/boost/type_traits/transform_traits.hpp b/boost/boost/type_traits/transform_traits.hpp new file mode 100644 index 0000000000..06171d81fd --- /dev/null +++ b/boost/boost/type_traits/transform_traits.hpp @@ -0,0 +1,200 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for transforming one type to another: +// remove_reference, add_reference, remove_bounds, remove_pointer. +// +// Revision History: +// 21st March 2001 +// Added void specialisations to add_reference. + +#ifndef BOOST_TRANSFORM_TRAITS_HPP +#define BOOST_TRANSFORM_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include +#endif +#if !defined(BOOST_COMPOSITE_TYPE_TRAITS_HPP) && defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#include +#endif + +namespace boost{ + +/********************************************** + * + * remove_reference + * + **********************************************/ +template +struct remove_reference +{ typedef T type; }; +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct remove_reference +{ typedef T type; }; +#endif +#if defined(__BORLANDC__) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// 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 +// references as distinct types... +template +struct remove_reference +{ typedef T type; }; +template +struct remove_reference +{ typedef T type; }; +template +struct remove_reference +{ typedef T type; }; +#endif + +/********************************************** + * + * add_reference + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct add_reference +{ typedef T& type; }; +template +struct add_reference +{ typedef T& type; }; +#elif defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES) +namespace detail{ + +template +struct reference_adder +{ + template + struct rebind + { + typedef T& type; + }; +}; + +template <> +struct reference_adder +{ + template + struct rebind + { + typedef T type; + }; +}; + +} // namespace detail + +template +struct add_reference +{ +private: + typedef typename detail::reference_adder< ::boost::is_reference::value>::template rebind binder; +public: + typedef typename binder::type type; +}; + +#else +template +struct add_reference +{ typedef T& type; }; +#endif + +// +// these full specialisations are always required: +template <> struct add_reference{ typedef void type; }; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct add_reference{ typedef const volatile void type; }; +template <> struct add_reference{ typedef const void type; }; +template <> struct add_reference{ typedef volatile void type; }; +#endif + + +/********************************************** + * + * remove_bounds + * + **********************************************/ +template +struct remove_bounds +{ typedef T type; }; +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct remove_bounds +{ typedef T type; }; +template +struct remove_bounds +{ typedef const T type; }; +template +struct remove_bounds +{ typedef volatile T type; }; +template +struct remove_bounds +{ typedef const volatile T type; }; +#endif + +/********************************************** + * + * remove_pointer + * + **********************************************/ +template +struct remove_pointer +{ typedef T type; }; +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct remove_pointer +{ typedef T type; }; +template +struct remove_pointer +{ typedef T type; }; +template +struct remove_pointer +{ typedef T type; }; +template +struct remove_pointer +{ typedef T type; }; +#endif + +/********************************************** + * + * add_pointer + * + **********************************************/ +template +struct add_pointer +{ +private: + typedef typename remove_reference::type no_ref_type; + typedef typename remove_bounds::type no_b_type; +public: + typedef no_b_type* type; +}; + +} // namespace boost + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +// +// if there is no partial specialisation support +// include a bunch of full specialisations as a workaround: +// +#include +#else +#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x) +#endif + +#endif // BOOST_TRANSFORM_TRAITS_HPP + + + + + diff --git a/boost/boost/type_traits/transform_traits_spec.hpp b/boost/boost/type_traits/transform_traits_spec.hpp new file mode 100644 index 0000000000..e9fd0cbf8a --- /dev/null +++ b/boost/boost/type_traits/transform_traits_spec.hpp @@ -0,0 +1,78 @@ + +// Copyright (c) 2001 Aleksey Gurtovoy. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears 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. + +#ifndef BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP +#define BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP + +#ifndef TRANSFORM_TRAITS_HPP +#include +#endif + +#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_CONST_VOLATILE_RANK1(T) \ +template<> struct remove_const { typedef T type; }; \ +template<> struct remove_const { typedef T volatile type; }; \ +template<> struct remove_volatile { typedef T type; }; \ +template<> struct remove_volatile { typedef T const type; }; \ +template<> struct remove_cv { typedef T type; }; \ +template<> struct remove_cv { typedef T type; }; \ +template<> struct remove_cv { typedef T type; }; \ +/**/ + +#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T) \ +template<> struct remove_pointer { typedef T type; }; \ +template<> struct remove_reference { typedef T type; }; \ +/**/ + +#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_2(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T const) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T volatile) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T const volatile) \ +/**/ + +#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_2(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_CONST_VOLATILE_RANK1(T) \ +/**/ + +#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T*) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T const*) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T volatile*) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T const volatile*) \ +/**/ + +#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \ +namespace boost { \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T*) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T const*) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T volatile*) \ +BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T const volatile*) \ +} \ +/**/ + +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(bool) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(char) +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(wchar_t) +#endif +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed char) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned char) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed short) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned short) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed int) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned int) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed long) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned long) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(float) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(double) +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(long double) + +#endif // BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP + diff --git a/boost/boost/type_traits/type_traits_test.hpp b/boost/boost/type_traits/type_traits_test.hpp new file mode 100644 index 0000000000..b96feab9ec --- /dev/null +++ b/boost/boost/type_traits/type_traits_test.hpp @@ -0,0 +1,393 @@ +// (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// 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. + +// common test code for type-traits tests +// WARNING: contains code as well as declarations! + + +#ifndef BOOST_TYPE_TRAITS_TEST_HPP +#define BOOST_TYPE_TRAITS_TEST_HPP +#include +#include +#include +// +// define tests here +unsigned failures = 0; +unsigned test_count = 0; +// +// This must get defined within the test file. +// All compilers have bugs, set this to the number of +// regressions *expected* from a given compiler, +// if there are no workarounds for the bugs, *and* +// the regressions have been investigated. +// +extern unsigned int expected_failures; +// +// proc check_result() +// Checks that there were no regressions: +// +int check_result(int argc, char** argv) +{ + std::cout << test_count << " tests completed, " + << failures << " failures found, " + << expected_failures << " failures expected from this compiler." << std::endl; + if((argc == 2) + && (argv[1][0] == '-') + && (argv[1][1] == 'a') + && (argv[1][2] == 0)) + { + std::cout << "Press any key to continue..."; + std::cin.get(); + } + return (failures == expected_failures) ? 0 : failures; +} + + +// +// this one is to verify that a constant is indeed a +// constant-integral-expression: +// +// HP aCC cannot deal with missing names for template value parameters +template +struct checker +{ + static void check(bool, bool, const char*, bool){ ++test_count; } +}; + +template <> +struct checker +{ + static void check(bool o, bool n, const char* name, bool soft) + { + ++test_count; + ++failures; + // if this is a soft test, then failure is expected, + // or may depend upon factors outside our control + // (like compiler options)... + if(soft)++expected_failures; + std::cout << "checking value of " << name << "...failed" << std::endl; + std::cout << "\tfound: " << n << " expected " << o << std::endl; + } +}; + +template +struct type_checker +{ + static void check(const char* TT, const char* TU, const char* expression) + { + ++test_count; +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + if((typeid(T) != typeid(U)) + || (::boost::is_reference::value != ::boost::is_reference::value) + || (::boost::is_const::value != ::boost::is_const::value) + || (::boost::is_volatile::value != ::boost::is_volatile::value)) + { +#endif + ++failures; + std::cout << "checking type of " << expression << "...failed" << std::endl; + std::cout << " expected type was " << TT << std::endl; + std::cout << " typeid(" << TT << ") was: " << typeid(T).name() << std::endl; + std::cout << " typeid(" << TU << ") was: " << typeid(U).name() << std::endl; + std::cout << " In template class " << typeid(type_checker).name() << std::endl; +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + } +#endif + } +}; + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct type_checker +{ + static void check(const char*, const char*, const char*) + { + ++test_count; + } +}; +#endif + + +#define value_test(v, x) checker<(v == x)>::check(v, x, #x, false); +#define soft_value_test(v, x) checker<(v == x)>::check(v, x, #x, true); + +#define value_fail(v, x) \ + ++test_count; \ + ++failures; \ + std::cout << "checking value of " << #x << "...failed" << std::endl; \ + std::cout << " " #x " does not compile on this compiler" << std::endl; + + +#define type_test(v, x) type_checker::check(#v, #x, #x); +#define type_test3(v, x, z) type_checker::check(#v, #x "," #z, #x "," #z); +#ifndef SHORT_TRANSFORM_TEST +#define transform_check(name, from_suffix, to_suffix)\ + type_test(bool to_suffix, name::type);\ + type_test(char to_suffix, name::type);\ + type_test(wchar_t to_suffix, name::type);\ + type_test(signed char to_suffix, name::type);\ + type_test(unsigned char to_suffix, name::type);\ + type_test(short to_suffix, name::type);\ + type_test(unsigned short to_suffix, name::type);\ + type_test(int to_suffix, name::type);\ + type_test(unsigned int to_suffix, name::type);\ + type_test(long to_suffix, name::type);\ + type_test(unsigned long to_suffix, name::type);\ + type_test(float to_suffix, name::type);\ + type_test(long double to_suffix, name::type);\ + type_test(double to_suffix, name::type);\ + type_test(UDT to_suffix, name::type);\ + type_test(enum1 to_suffix, name::type); +#else +#define transform_check(name, from_suffix, to_suffix)\ + type_test(int to_suffix, name::type);\ + type_test(UDT to_suffix, name::type);\ + type_test(enum1 to_suffix, name::type); +#endif + +#define boost_dummy_macro_param + +template +struct test_align +{ + struct padded + { + char c; + T t; + }; + static void do_it() + { + padded p; + unsigned a = reinterpret_cast(&(p.t)) - reinterpret_cast(&p); + ++test_count; + // only fail if we do not have a multiple of the actual value: + if((a > ::boost::alignment_of::value) || (a % ::boost::alignment_of::value)) + { + ++failures; + std::cout << "checking value of " << typeid(boost::alignment_of).name() << "...failed" << std::endl; + std::cout << "\tfound: " << boost::alignment_of::value << " expected " << a << std::endl; + } + // suppress warnings about unused variables: + (void)p; + (void)a; + } +}; +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct test_align +{ + static void do_it() + { + // + // we can't do the usual test because we can't take the address + // of a reference, so check that the result is the same as for a + // pointer type instead: + unsigned a = boost::alignment_of::value; + ++test_count; + if(a != boost::alignment_of::value) + { + ++failures; + std::cout << "checking value of " << typeid(boost::alignment_of).name() << "...failed" << std::endl; + std::cout << "\tfound: " << boost::alignment_of::value << " expected " << a << std::endl; + } + } +}; +#endif + +#define align_test(T) test_align::do_it() + +// +// the following code allows us to test that a particular +// template functions correctly when instanciated inside another template +// (some bugs only show up in that situation). For each template +// we declare one NESTED_DECL(classname) that sets up the template class +// and multiple NESTED_TEST(classname, template-arg) declarations, to carry +// the actual tests: +template +struct nested_test +{ + typedef nested_test type; + bool run_time_value; + const char* what; + nested_test(bool b2, const char* w) : run_time_value(b2), what(w) { check(); } + void check() + { + ++test_count; + if(b != run_time_value) + { + ++failures; + std::cerr << "Mismatch between runtime and compile time values in " << what << std::endl; + } + } +}; + +#ifndef __SUNPRO_CC +#define NESTED_DECL(what)\ +template \ +struct BOOST_TT_JOIN(nested_tester_,what){\ + nested_test< (::boost::type_traits::ice_ne<0, ::boost::what::value>::value)> tester;\ + BOOST_TT_JOIN(nested_tester_,what)(const char* s) : tester(::boost::what::value, s){}\ +}; +#define NESTED_TEST(what, with)\ +{BOOST_TT_JOIN(nested_tester_,what) check(#what "<" #with ">"); (void)check;} +#else +#define NESTED_DECL(what) +#define NESTED_TEST(what, with) +#endif + +#define BOOST_TT_JOIN( X, Y ) BOOST_DO_TT_JOIN( X, Y ) +#define BOOST_DO_TT_JOIN( X, Y ) X##Y + + + +// +// define some types to test with: +// +enum enum_UDT{ one, two, three }; +struct UDT +{ + UDT(){}; + ~UDT(){}; + UDT(const UDT&); + UDT& operator=(const UDT&); + int i; + + void f1(); + int f2(); + int f3(int); + int f4(int, float); +}; + +typedef void(*f1)(); +typedef int(*f2)(int); +typedef int(*f3)(int, bool); +typedef void (UDT::*mf1)(); +typedef int (UDT::*mf2)(); +typedef int (UDT::*mf3)(int); +typedef int (UDT::*mf4)(int, float); +typedef int (UDT::*mp); + +// cv-qualifiers applied to reference types should have no effect +// declare these here for later use with is_reference and remove_reference: +# ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4181) +# endif // BOOST_MSVC +typedef int& r_type; +typedef const r_type cr_type; +# ifdef BOOST_MSVC +# pragma warning(pop) +# endif // BOOST_MSVC + +struct POD_UDT { int x; }; +struct empty_UDT +{ + ~empty_UDT(){}; + empty_UDT& operator=(const empty_UDT&){ return *this; } + bool operator==(const empty_UDT&)const + { return true; } +}; +struct empty_POD_UDT +{ + empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; } + bool operator==(const empty_POD_UDT&)const + { return true; } +}; +union union_UDT +{ + int x; + double y; + ~union_UDT(); +}; +union POD_union_UDT +{ + int x; + double y; +}; +union empty_union_UDT +{ + ~empty_union_UDT(); +}; +union empty_POD_union_UDT{}; + +class Base { }; + +class Deriverd : public Base { }; + +class NonDerived { }; + +enum enum1 +{ + one_,two_ +}; + +enum enum2 +{ + three_,four_ +}; + +struct VB +{ + virtual ~VB(){}; +}; + +struct VD : VB +{ + ~VD(){}; +}; +// +// struct non_pointer: +// used to verify that is_pointer does not return +// true for class types that implement operator void*() +// +struct non_pointer +{ + operator void*(){return this;} +}; +struct non_int_pointer +{ + int i; + operator int*(){return &i;} +}; +struct int_constructible +{ + int_constructible(int); +}; +struct int_convertible +{ + operator int(); +}; +// +// struct non_empty: +// used to verify that is_empty does not emit +// spurious warnings or errors. +// +struct non_empty : boost::noncopyable +{ + int i; +}; +// +// abstract base classes: +struct test_abc1 +{ + virtual void foo() = 0; + virtual void foo2() = 0; +}; + +struct test_abc2 +{ + virtual void foo() = 0; + virtual void foo2() = 0; +}; + + +#endif // BOOST_TYPE_TRAITS_TEST_HPP + + + + + + + + diff --git a/boost/boost/utility.hpp b/boost/boost/utility.hpp index f1a6389139..fa99b9a148 100644 --- a/boost/boost/utility.hpp +++ b/boost/boost/utility.hpp @@ -87,31 +87,6 @@ namespace boost const noncopyable& operator=( const noncopyable& ); }; // noncopyable -// class tied -------------------------------------------------------// - - // A helper for conveniently assigning the two values from a pair - // into separate variables. The idea for this comes from Jaakko J„rvi's - // Binder/Lambda Library. - - // Constributed by Jeremy Siek - - template - class tied { - public: - inline tied(A& a, B& b) : _a(a), _b(b) { } - template - inline tied& operator=(const std::pair& p) { - _a = p.first; - _b = p.second; - return *this; - } - protected: - A& _a; - B& _b; - }; - - template - inline tied tie(A& a, B& b) { return tied(a, b); } } // namespace boost -- 2.39.2