diff options
Diffstat (limited to 'boost/detail')
61 files changed, 7698 insertions, 0 deletions
diff --git a/boost/detail/algorithm.hpp b/boost/detail/algorithm.hpp new file mode 100644 index 0000000000..3f9297bcab --- /dev/null +++ b/boost/detail/algorithm.hpp @@ -0,0 +1,82 @@ +// (C) Copyright Jeremy Siek 2001. +// Distributed under the Boost Software License, Version 1.0. (See accompany- +// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +#ifndef BOOST_ALGORITHM_HPP +# define BOOST_ALGORITHM_HPP +# include <boost/detail/iterator.hpp> +// Algorithms on sequences +// +// The functions in this file have not yet gone through formal +// review, and are subject to change. This is a work in progress. +// They have been checked into the detail directory because +// there are some graph algorithms that use these functions. + +#include <algorithm> +#include <vector> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/algorithm/copy.hpp> +#include <boost/range/algorithm/equal.hpp> +#include <boost/range/algorithm/sort.hpp> +#include <boost/range/algorithm/stable_sort.hpp> +#include <boost/range/algorithm/find_if.hpp> +#include <boost/range/algorithm/count.hpp> +#include <boost/range/algorithm/count_if.hpp> +#include <boost/range/algorithm_ext/is_sorted.hpp> +#include <boost/range/algorithm_ext/iota.hpp> + +namespace boost { + + template <typename InputIterator, typename Predicate> + bool any_if(InputIterator first, InputIterator last, Predicate p) + { + return std::find_if(first, last, p) != last; + } + + template <typename Container, typename Predicate> + bool any_if(const Container& c, Predicate p) + { + return any_if(boost::begin(c), boost::end(c), p); + } + + template <typename InputIterator, typename T> + bool container_contains(InputIterator first, InputIterator last, T value) + { + return std::find(first, last, value) != last; + } + template <typename Container, typename T> + bool container_contains(const Container& c, const T& value) + { + return container_contains(boost::begin(c), boost::end(c), value); + } + +} // namespace boost + +#endif // BOOST_ALGORITHM_HPP diff --git a/boost/detail/allocator_utilities.hpp b/boost/detail/allocator_utilities.hpp new file mode 100644 index 0000000000..5d6ef48b05 --- /dev/null +++ b/boost/detail/allocator_utilities.hpp @@ -0,0 +1,212 @@ +/* Copyright 2003-2009 Joaquin M Lopez Munoz. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * See Boost website at http://www.boost.org/ + */ + +#ifndef BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP +#define BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP + +#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */ +#include <boost/detail/workaround.hpp> +#include <boost/mpl/aux_/msvc_never_true.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/type_traits/is_same.hpp> +#include <cstddef> +#include <memory> +#include <new> + +namespace boost{ + +namespace detail{ + +/* Allocator adaption layer. Some stdlibs provide allocators without rebind + * and template ctors. These facilities are simulated with the external + * template class rebind_to and the aid of partial_std_allocator_wrapper. + */ + +namespace allocator{ + +/* partial_std_allocator_wrapper inherits the functionality of a std + * allocator while providing a templatized ctor and other bits missing + * in some stdlib implementation or another. + */ + +template<typename Type> +class partial_std_allocator_wrapper:public std::allocator<Type> +{ +public: + /* Oddly enough, STLport does not define std::allocator<void>::value_type + * when configured to work without partial template specialization. + * No harm in supplying the definition here unconditionally. + */ + + typedef Type value_type; + + partial_std_allocator_wrapper(){}; + + template<typename Other> + partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){} + + partial_std_allocator_wrapper(const std::allocator<Type>& x): + std::allocator<Type>(x) + { + }; + +#if defined(BOOST_DINKUMWARE_STDLIB) + /* Dinkumware guys didn't provide a means to call allocate() without + * supplying a hint, in disagreement with the standard. + */ + + Type* allocate(std::size_t n,const void* hint=0) + { + std::allocator<Type>& a=*this; + return a.allocate(n,hint); + } +#endif + +}; + +/* Detects whether a given allocator belongs to a defective stdlib not + * having the required member templates. + * Note that it does not suffice to check the Boost.Config stdlib + * macros, as the user might have passed a custom, compliant allocator. + * The checks also considers partial_std_allocator_wrapper to be + * a standard defective allocator. + */ + +#if defined(BOOST_NO_STD_ALLOCATOR)&&\ + (defined(BOOST_HAS_PARTIAL_STD_ALLOCATOR)||defined(BOOST_DINKUMWARE_STDLIB)) + +template<typename Allocator> +struct is_partial_std_allocator +{ + BOOST_STATIC_CONSTANT(bool, + value= + (is_same< + std::allocator<BOOST_DEDUCED_TYPENAME Allocator::value_type>, + Allocator + >::value)|| + (is_same< + partial_std_allocator_wrapper< + BOOST_DEDUCED_TYPENAME Allocator::value_type>, + Allocator + >::value)); +}; + +#else + +template<typename Allocator> +struct is_partial_std_allocator +{ + BOOST_STATIC_CONSTANT(bool,value=false); +}; + +#endif + +/* rebind operations for defective std allocators */ + +template<typename Allocator,typename Type> +struct partial_std_allocator_rebind_to +{ + typedef partial_std_allocator_wrapper<Type> type; +}; + +/* rebind operation in all other cases */ + +#if BOOST_WORKAROUND(BOOST_MSVC,<1300) +/* Workaround for a problem in MSVC with dependent template typedefs + * when doing rebinding of allocators. + * Modeled after <boost/mpl/aux_/msvc_dtw.hpp> (thanks, Aleksey!) + */ + +template<typename Allocator> +struct rebinder +{ + template<bool> struct fake_allocator:Allocator{}; + template<> struct fake_allocator<true> + { + template<typename Type> struct rebind{}; + }; + + template<typename Type> + struct result: + fake_allocator<mpl::aux::msvc_never_true<Allocator>::value>:: + template rebind<Type> + { + }; +}; +#else +template<typename Allocator> +struct rebinder +{ + template<typename Type> + struct result + { + typedef typename Allocator::BOOST_NESTED_TEMPLATE + rebind<Type>::other other; + }; +}; +#endif + +template<typename Allocator,typename Type> +struct compliant_allocator_rebind_to +{ + typedef typename rebinder<Allocator>:: + BOOST_NESTED_TEMPLATE result<Type>::other type; +}; + +/* rebind front-end */ + +template<typename Allocator,typename Type> +struct rebind_to: + mpl::eval_if_c< + is_partial_std_allocator<Allocator>::value, + partial_std_allocator_rebind_to<Allocator,Type>, + compliant_allocator_rebind_to<Allocator,Type> + > +{ +}; + +/* allocator-independent versions of construct and destroy */ + +template<typename Type> +void construct(void* p,const Type& t) +{ + new (p) Type(t); +} + +#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500)) +/* MSVC++ issues spurious warnings about unreferencend formal parameters + * in destroy<Type> when Type is a class with trivial dtor. + */ + +#pragma warning(push) +#pragma warning(disable:4100) +#endif + +template<typename Type> +void destroy(const Type* p) +{ + +#if BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590)) + const_cast<Type*>(p)->~Type(); +#else + p->~Type(); +#endif + +} + +#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500)) +#pragma warning(pop) +#endif + +} /* namespace boost::detail::allocator */ + +} /* namespace boost::detail */ + +} /* namespace boost */ + +#endif diff --git a/boost/detail/atomic_count.hpp b/boost/detail/atomic_count.hpp new file mode 100644 index 0000000000..5411c7ae99 --- /dev/null +++ b/boost/detail/atomic_count.hpp @@ -0,0 +1,21 @@ +#ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED +#define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/atomic_count.hpp - thread/SMP safe reference counter +// +// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt + +#include <boost/smart_ptr/detail/atomic_count.hpp> + +#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED diff --git a/boost/detail/binary_search.hpp b/boost/detail/binary_search.hpp new file mode 100644 index 0000000000..3dca9b6509 --- /dev/null +++ b/boost/detail/binary_search.hpp @@ -0,0 +1,216 @@ +// Copyright (c) 2000 David Abrahams. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// Copyright (c) 1994 +// Hewlett-Packard Company +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appear in all copies and +// that both that copyright notice and this permission notice appear +// in supporting documentation. Hewlett-Packard Company makes no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied warranty. +// +// Copyright (c) 1996 +// Silicon Graphics Computer Systems, Inc. +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appear in all copies and +// that both that copyright notice and this permission notice appear +// in supporting documentation. Silicon Graphics makes no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied warranty. +// +#ifndef BINARY_SEARCH_DWA_122600_H_ +# define BINARY_SEARCH_DWA_122600_H_ + +# include <boost/detail/iterator.hpp> +# include <utility> + +namespace boost { namespace detail { + +template <class ForwardIter, class Tp> +ForwardIter lower_bound(ForwardIter first, ForwardIter last, + const Tp& val) +{ + typedef detail::iterator_traits<ForwardIter> traits; + + typename traits::difference_type len = boost::detail::distance(first, last); + typename traits::difference_type half; + ForwardIter middle; + + while (len > 0) { + half = len >> 1; + middle = first; + std::advance(middle, half); + if (*middle < val) { + first = middle; + ++first; + len = len - half - 1; + } + else + len = half; + } + return first; +} + +template <class ForwardIter, class Tp, class Compare> +ForwardIter lower_bound(ForwardIter first, ForwardIter last, + const Tp& val, Compare comp) +{ + typedef detail::iterator_traits<ForwardIter> traits; + + typename traits::difference_type len = boost::detail::distance(first, last); + typename traits::difference_type half; + ForwardIter middle; + + while (len > 0) { + half = len >> 1; + middle = first; + std::advance(middle, half); + if (comp(*middle, val)) { + first = middle; + ++first; + len = len - half - 1; + } + else + len = half; + } + return first; +} + +template <class ForwardIter, class Tp> +ForwardIter upper_bound(ForwardIter first, ForwardIter last, + const Tp& val) +{ + typedef detail::iterator_traits<ForwardIter> traits; + + typename traits::difference_type len = boost::detail::distance(first, last); + typename traits::difference_type half; + ForwardIter middle; + + while (len > 0) { + half = len >> 1; + middle = first; + std::advance(middle, half); + if (val < *middle) + len = half; + else { + first = middle; + ++first; + len = len - half - 1; + } + } + return first; +} + +template <class ForwardIter, class Tp, class Compare> +ForwardIter upper_bound(ForwardIter first, ForwardIter last, + const Tp& val, Compare comp) +{ + typedef detail::iterator_traits<ForwardIter> traits; + + typename traits::difference_type len = boost::detail::distance(first, last); + typename traits::difference_type half; + ForwardIter middle; + + while (len > 0) { + half = len >> 1; + middle = first; + std::advance(middle, half); + if (comp(val, *middle)) + len = half; + else { + first = middle; + ++first; + len = len - half - 1; + } + } + return first; +} + +template <class ForwardIter, class Tp> +std::pair<ForwardIter, ForwardIter> +equal_range(ForwardIter first, ForwardIter last, const Tp& val) +{ + typedef detail::iterator_traits<ForwardIter> traits; + + typename traits::difference_type len = boost::detail::distance(first, last); + typename traits::difference_type half; + ForwardIter middle, left, right; + + while (len > 0) { + half = len >> 1; + middle = first; + std::advance(middle, half); + if (*middle < val) { + first = middle; + ++first; + len = len - half - 1; + } + else if (val < *middle) + len = half; + else { + left = boost::detail::lower_bound(first, middle, val); + std::advance(first, len); + right = boost::detail::upper_bound(++middle, first, val); + return std::pair<ForwardIter, ForwardIter>(left, right); + } + } + return std::pair<ForwardIter, ForwardIter>(first, first); +} + +template <class ForwardIter, class Tp, class Compare> +std::pair<ForwardIter, ForwardIter> +equal_range(ForwardIter first, ForwardIter last, const Tp& val, + Compare comp) +{ + typedef detail::iterator_traits<ForwardIter> traits; + + typename traits::difference_type len = boost::detail::distance(first, last); + typename traits::difference_type half; + ForwardIter middle, left, right; + + while (len > 0) { + half = len >> 1; + middle = first; + std::advance(middle, half); + if (comp(*middle, val)) { + first = middle; + ++first; + len = len - half - 1; + } + else if (comp(val, *middle)) + len = half; + else { + left = boost::detail::lower_bound(first, middle, val, comp); + std::advance(first, len); + right = boost::detail::upper_bound(++middle, first, val, comp); + return std::pair<ForwardIter, ForwardIter>(left, right); + } + } + return std::pair<ForwardIter, ForwardIter>(first, first); +} + +template <class ForwardIter, class Tp> +bool binary_search(ForwardIter first, ForwardIter last, + const Tp& val) { + ForwardIter i = boost::detail::lower_bound(first, last, val); + return i != last && !(val < *i); +} + +template <class ForwardIter, class Tp, class Compare> +bool binary_search(ForwardIter first, ForwardIter last, + const Tp& val, + Compare comp) { + ForwardIter i = boost::detail::lower_bound(first, last, val, comp); + return i != last && !comp(val, *i); +} + +}} // namespace boost::detail + +#endif // BINARY_SEARCH_DWA_122600_H_ diff --git a/boost/detail/bitmask.hpp b/boost/detail/bitmask.hpp new file mode 100644 index 0000000000..c6714a1109 --- /dev/null +++ b/boost/detail/bitmask.hpp @@ -0,0 +1,47 @@ +// boost/detail/bitmask.hpp ------------------------------------------------// + +// Copyright Beman Dawes 2006 + +// Distributed under the Boost Software License, Version 1.0 +// http://www.boost.org/LICENSE_1_0.txt + +// Usage: enum foo { a=1, b=2, c=4 }; +// BOOST_BITMASK( foo ); +// +// void f( foo arg ); +// ... +// f( a | c ); + +#ifndef BOOST_BITMASK_HPP +#define BOOST_BITMASK_HPP + +#include <boost/cstdint.hpp> + +#define BOOST_BITMASK(Bitmask) \ + \ + inline Bitmask operator| (Bitmask x , Bitmask y ) \ + { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x) \ + | static_cast<boost::int_least32_t>(y)); } \ + \ + inline Bitmask operator& (Bitmask x , Bitmask y ) \ + { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x) \ + & static_cast<boost::int_least32_t>(y)); } \ + \ + inline Bitmask operator^ (Bitmask x , Bitmask y ) \ + { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x) \ + ^ static_cast<boost::int_least32_t>(y)); } \ + \ + inline Bitmask operator~ (Bitmask x ) \ + { return static_cast<Bitmask>(~static_cast<boost::int_least32_t>(x)); } \ + \ + inline Bitmask & operator&=(Bitmask & x , Bitmask y) \ + { x = x & y ; return x ; } \ + \ + inline Bitmask & operator|=(Bitmask & x , Bitmask y) \ + { x = x | y ; return x ; } \ + \ + inline Bitmask & operator^=(Bitmask & x , Bitmask y) \ + { x = x ^ y ; return x ; } + +#endif // BOOST_BITMASK_HPP + diff --git a/boost/detail/call_traits.hpp b/boost/detail/call_traits.hpp new file mode 100644 index 0000000000..6ad646ec60 --- /dev/null +++ b/boost/detail/call_traits.hpp @@ -0,0 +1,164 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. + +// call_traits: defines typedefs for function usage +// (see libs/utility/call_traits.htm) + +/* Release notes: + 23rd July 2000: + Fixed array specialization. (JM) + Added Borland specific fixes for reference types + (issue raised by Steve Cleary). +*/ + +#ifndef BOOST_DETAIL_CALL_TRAITS_HPP +#define BOOST_DETAIL_CALL_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +#include <boost/config.hpp> +#endif +#include <cstddef> + +#include <boost/type_traits/is_arithmetic.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/detail/workaround.hpp> + +namespace boost{ + +namespace detail{ + +template <typename T, bool small_> +struct ct_imp2 +{ + typedef const T& param_type; +}; + +template <typename T> +struct ct_imp2<T, true> +{ + typedef const T param_type; +}; + +template <typename T, bool isp, bool b1> +struct ct_imp +{ + typedef const T& param_type; +}; + +template <typename T, bool isp> +struct ct_imp<T, isp, true> +{ + typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type; +}; + +template <typename T, bool b1> +struct ct_imp<T, true, b1> +{ + typedef const T param_type; +}; + +} + +template <typename T> +struct call_traits +{ +public: + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + // + // C++ Builder workaround: we should be able to define a compile time + // constant and pass that as a single template parameter to ct_imp<T,bool>, + // however compiler bugs prevent this - instead pass three bool's to + // ct_imp<T,bool,bool,bool> and add an extra partial specialisation + // of ct_imp to handle the logic. (JM) + typedef typename boost::detail::ct_imp< + T, + ::boost::is_pointer<T>::value, + ::boost::is_arithmetic<T>::value + >::param_type param_type; +}; + +template <typename T> +struct call_traits<T&> +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; + +#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 ) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +template <typename T> +struct call_traits<T&const> +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; +template <typename T> +struct call_traits<T&volatile> +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; +template <typename T> +struct call_traits<T&const volatile> +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; + +template <typename T> +struct call_traits< T * > +{ + typedef T * value_type; + typedef T * & reference; + typedef T * const & const_reference; + typedef T * const param_type; // hh removed const +}; +#endif +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +template <typename T, std::size_t N> +struct call_traits<T [N]> +{ +private: + typedef T array_type[N]; +public: + // degrades array to pointer: + typedef const T* value_type; + typedef array_type& reference; + typedef const array_type& const_reference; + typedef const T* const param_type; +}; + +template <typename T, std::size_t N> +struct call_traits<const T [N]> +{ +private: + typedef const T array_type[N]; +public: + // degrades array to pointer: + typedef const T* value_type; + typedef array_type& reference; + typedef const array_type& const_reference; + typedef const T* const param_type; +}; +#endif + +} + +#endif // BOOST_DETAIL_CALL_TRAITS_HPP diff --git a/boost/detail/catch_exceptions.hpp b/boost/detail/catch_exceptions.hpp new file mode 100644 index 0000000000..b1a3c76b2a --- /dev/null +++ b/boost/detail/catch_exceptions.hpp @@ -0,0 +1,146 @@ +// boost/catch_exceptions.hpp -----------------------------------------------// + +// Copyright Beman Dawes 1995-2001. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/test for documentation. + +// Revision History +// 13 Jun 01 report_exception() made inline. (John Maddock, Jesse Jones) +// 26 Feb 01 Numerous changes suggested during formal review. (Beman) +// 25 Jan 01 catch_exceptions.hpp code factored out of cpp_main.cpp. +// 22 Jan 01 Remove test_tools dependencies to reduce coupling. +// 5 Nov 00 Initial boost version (Beman Dawes) + +#ifndef BOOST_CATCH_EXCEPTIONS_HPP +#define BOOST_CATCH_EXCEPTIONS_HPP + +// header dependencies are deliberately restricted to the standard library +// to reduce coupling to other boost libraries. +#include <string> // for string +#include <new> // for bad_alloc +#include <typeinfo> // for bad_cast, bad_typeid +#include <exception> // for exception, bad_exception +#include <stdexcept> // for std exception hierarchy +#include <boost/cstdlib.hpp> // for exit codes +# if __GNUC__ != 2 || __GNUC_MINOR__ > 96 +# include <ostream> // for ostream +# else +# include <iostream> // workaround GNU missing ostream header +# endif + +# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0551) +# define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT +# endif + +#if defined(MPW_CPLUS) && (MPW_CPLUS <= 0x890) +# define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT + namespace std { class bad_typeid { }; } +# endif + +namespace boost +{ + + namespace detail + { + // A separate reporting function was requested during formal review. + inline void report_exception( std::ostream & os, + const char * name, const char * info ) + { os << "\n** uncaught exception: " << name << " " << info << std::endl; } + } + + // catch_exceptions ------------------------------------------------------// + + template< class Generator > // Generator is function object returning int + int catch_exceptions( Generator function_object, + std::ostream & out, std::ostream & err ) + { + int result = 0; // quiet compiler warnings + bool exception_thrown = true; // avoid setting result for each excptn type + +#ifndef BOOST_NO_EXCEPTIONS + try + { +#endif + result = function_object(); + exception_thrown = false; +#ifndef BOOST_NO_EXCEPTIONS + } + + // As a result of hard experience with strangely interleaved output + // under some compilers, there is a lot of use of endl in the code below + // where a simple '\n' might appear to do. + + // The rules for catch & arguments are a bit different from function + // arguments (ISO 15.3 paragraphs 18 & 19). Apparently const isn't + // required, but it doesn't hurt and some programmers ask for it. + + catch ( const char * ex ) + { detail::report_exception( out, "", ex ); } + catch ( const std::string & ex ) + { detail::report_exception( out, "", ex.c_str() ); } + + // std:: exceptions + catch ( const std::bad_alloc & ex ) + { detail::report_exception( out, "std::bad_alloc:", ex.what() ); } + +# ifndef BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT + catch ( const std::bad_cast & ex ) + { detail::report_exception( out, "std::bad_cast:", ex.what() ); } + catch ( const std::bad_typeid & ex ) + { detail::report_exception( out, "std::bad_typeid:", ex.what() ); } +# else + catch ( const std::bad_cast & ) + { detail::report_exception( out, "std::bad_cast", "" ); } + catch ( const std::bad_typeid & ) + { detail::report_exception( out, "std::bad_typeid", "" ); } +# endif + + catch ( const std::bad_exception & ex ) + { detail::report_exception( out, "std::bad_exception:", ex.what() ); } + catch ( const std::domain_error & ex ) + { detail::report_exception( out, "std::domain_error:", ex.what() ); } + catch ( const std::invalid_argument & ex ) + { detail::report_exception( out, "std::invalid_argument:", ex.what() ); } + catch ( const std::length_error & ex ) + { detail::report_exception( out, "std::length_error:", ex.what() ); } + catch ( const std::out_of_range & ex ) + { detail::report_exception( out, "std::out_of_range:", ex.what() ); } + catch ( const std::range_error & ex ) + { detail::report_exception( out, "std::range_error:", ex.what() ); } + catch ( const std::overflow_error & ex ) + { detail::report_exception( out, "std::overflow_error:", ex.what() ); } + catch ( const std::underflow_error & ex ) + { detail::report_exception( out, "std::underflow_error:", ex.what() ); } + catch ( const std::logic_error & ex ) + { detail::report_exception( out, "std::logic_error:", ex.what() ); } + catch ( const std::runtime_error & ex ) + { detail::report_exception( out, "std::runtime_error:", ex.what() ); } + catch ( const std::exception & ex ) + { detail::report_exception( out, "std::exception:", ex.what() ); } + + catch ( ... ) + { detail::report_exception( out, "unknown exception", "" ); } +#endif // BOOST_NO_EXCEPTIONS + + if ( exception_thrown ) result = boost::exit_exception_failure; + + if ( result != 0 && result != exit_success ) + { + out << std::endl << "**** returning with error code " + << result << std::endl; + err + << "********** errors detected; see stdout for details ***********" + << std::endl; + } +#if !defined(BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE) + else { out << std::flush << "no errors detected" << std::endl; } +#endif + return result; + } // catch_exceptions + +} // boost + +#endif // BOOST_CATCH_EXCEPTIONS_HPP + diff --git a/boost/detail/compressed_pair.hpp b/boost/detail/compressed_pair.hpp new file mode 100644 index 0000000000..3f326456ce --- /dev/null +++ b/boost/detail/compressed_pair.hpp @@ -0,0 +1,443 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. + +// compressed_pair: pair that "compresses" empty members +// (see libs/utility/compressed_pair.htm) +// +// JM changes 25 Jan 2004: +// For the case where T1 == T2 and both are empty, then first() and second() +// should return different objects. +// JM changes 25 Jan 2000: +// Removed default arguments from compressed_pair_switch to get +// C++ Builder 4 to accept them +// rewriten swap to get gcc and C++ builder to compile. +// added partial specialisations for case T1 == T2 to avoid duplicate constructor defs. + +#ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP +#define BOOST_DETAIL_COMPRESSED_PAIR_HPP + +#include <algorithm> + +#include <boost/type_traits/remove_cv.hpp> +#include <boost/type_traits/is_empty.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/call_traits.hpp> + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable:4512) +#endif +namespace boost +{ + +template <class T1, class T2> +class compressed_pair; + + +// compressed_pair + +namespace details +{ + // JM altered 26 Jan 2000: + template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty> + struct compressed_pair_switch; + + template <class T1, class T2> + struct compressed_pair_switch<T1, T2, false, false, false> + {static const int value = 0;}; + + template <class T1, class T2> + struct compressed_pair_switch<T1, T2, false, true, true> + {static const int value = 3;}; + + template <class T1, class T2> + struct compressed_pair_switch<T1, T2, false, true, false> + {static const int value = 1;}; + + template <class T1, class T2> + struct compressed_pair_switch<T1, T2, false, false, true> + {static const int value = 2;}; + + template <class T1, class T2> + struct compressed_pair_switch<T1, T2, true, true, true> + {static const int value = 4;}; + + template <class T1, class T2> + struct compressed_pair_switch<T1, T2, true, false, false> + {static const int value = 5;}; + + template <class T1, class T2, int Version> class compressed_pair_imp; + +#ifdef __GNUC__ + // workaround for GCC (JM): + using std::swap; +#endif + // + // can't call unqualified swap from within classname::swap + // as Koenig lookup rules will find only the classname::swap + // member function not the global declaration, so use cp_swap + // as a forwarding function (JM): + template <typename T> + inline void cp_swap(T& t1, T& t2) + { +#ifndef __GNUC__ + using std::swap; +#endif + swap(t1, t2); + } + + // 0 derive from neither + + template <class T1, class T2> + class compressed_pair_imp<T1, T2, 0> + { + public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_imp() {} + + compressed_pair_imp(first_param_type x, second_param_type y) + : first_(x), second_(y) {} + + compressed_pair_imp(first_param_type x) + : first_(x) {} + + compressed_pair_imp(second_param_type y) + : second_(y) {} + + first_reference first() {return first_;} + first_const_reference first() const {return first_;} + + second_reference second() {return second_;} + second_const_reference second() const {return second_;} + + void swap(::boost::compressed_pair<T1, T2>& y) + { + cp_swap(first_, y.first()); + cp_swap(second_, y.second()); + } + private: + first_type first_; + second_type second_; + }; + + // 1 derive from T1 + + template <class T1, class T2> + class compressed_pair_imp<T1, T2, 1> + : protected ::boost::remove_cv<T1>::type + { + public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_imp() {} + + compressed_pair_imp(first_param_type x, second_param_type y) + : first_type(x), second_(y) {} + + compressed_pair_imp(first_param_type x) + : first_type(x) {} + + compressed_pair_imp(second_param_type y) + : second_(y) {} + + first_reference first() {return *this;} + first_const_reference first() const {return *this;} + + second_reference second() {return second_;} + second_const_reference second() const {return second_;} + + void swap(::boost::compressed_pair<T1,T2>& y) + { + // no need to swap empty base class: + cp_swap(second_, y.second()); + } + private: + second_type second_; + }; + + // 2 derive from T2 + + template <class T1, class T2> + class compressed_pair_imp<T1, T2, 2> + : protected ::boost::remove_cv<T2>::type + { + public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_imp() {} + + compressed_pair_imp(first_param_type x, second_param_type y) + : second_type(y), first_(x) {} + + compressed_pair_imp(first_param_type x) + : first_(x) {} + + compressed_pair_imp(second_param_type y) + : second_type(y) {} + + first_reference first() {return first_;} + first_const_reference first() const {return first_;} + + second_reference second() {return *this;} + second_const_reference second() const {return *this;} + + void swap(::boost::compressed_pair<T1,T2>& y) + { + // no need to swap empty base class: + cp_swap(first_, y.first()); + } + + private: + first_type first_; + }; + + // 3 derive from T1 and T2 + + template <class T1, class T2> + class compressed_pair_imp<T1, T2, 3> + : protected ::boost::remove_cv<T1>::type, + protected ::boost::remove_cv<T2>::type + { + public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_imp() {} + + compressed_pair_imp(first_param_type x, second_param_type y) + : first_type(x), second_type(y) {} + + compressed_pair_imp(first_param_type x) + : first_type(x) {} + + compressed_pair_imp(second_param_type y) + : second_type(y) {} + + first_reference first() {return *this;} + first_const_reference first() const {return *this;} + + second_reference second() {return *this;} + second_const_reference second() const {return *this;} + // + // no need to swap empty bases: + void swap(::boost::compressed_pair<T1,T2>&) {} + }; + + // JM + // 4 T1 == T2, T1 and T2 both empty + // Originally this did not store an instance of T2 at all + // but that led to problems beause it meant &x.first() == &x.second() + // which is not true for any other kind of pair, so now we store an instance + // of T2 just in case the user is relying on first() and second() returning + // different objects (albeit both empty). + template <class T1, class T2> + class compressed_pair_imp<T1, T2, 4> + : protected ::boost::remove_cv<T1>::type + { + public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_imp() {} + + compressed_pair_imp(first_param_type x, second_param_type y) + : first_type(x), m_second(y) {} + + compressed_pair_imp(first_param_type x) + : first_type(x), m_second(x) {} + + first_reference first() {return *this;} + first_const_reference first() const {return *this;} + + second_reference second() {return m_second;} + second_const_reference second() const {return m_second;} + + void swap(::boost::compressed_pair<T1,T2>&) {} + private: + T2 m_second; + }; + + // 5 T1 == T2 and are not empty: //JM + + template <class T1, class T2> + class compressed_pair_imp<T1, T2, 5> + { + public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_imp() {} + + compressed_pair_imp(first_param_type x, second_param_type y) + : first_(x), second_(y) {} + + compressed_pair_imp(first_param_type x) + : first_(x), second_(x) {} + + first_reference first() {return first_;} + first_const_reference first() const {return first_;} + + second_reference second() {return second_;} + second_const_reference second() const {return second_;} + + void swap(::boost::compressed_pair<T1, T2>& y) + { + cp_swap(first_, y.first()); + cp_swap(second_, y.second()); + } + private: + first_type first_; + second_type second_; + }; + +} // details + +template <class T1, class T2> +class compressed_pair + : private ::boost::details::compressed_pair_imp<T1, T2, + ::boost::details::compressed_pair_switch< + T1, + T2, + ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value, + ::boost::is_empty<T1>::value, + ::boost::is_empty<T2>::value>::value> +{ +private: + typedef details::compressed_pair_imp<T1, T2, + ::boost::details::compressed_pair_switch< + T1, + T2, + ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value, + ::boost::is_empty<T1>::value, + ::boost::is_empty<T2>::value>::value> base; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair() : base() {} + compressed_pair(first_param_type x, second_param_type y) : base(x, y) {} + explicit compressed_pair(first_param_type x) : base(x) {} + explicit compressed_pair(second_param_type y) : base(y) {} + + first_reference first() {return base::first();} + first_const_reference first() const {return base::first();} + + second_reference second() {return base::second();} + second_const_reference second() const {return base::second();} + + void swap(compressed_pair& y) { base::swap(y); } +}; + +// JM +// Partial specialisation for case where T1 == T2: +// +template <class T> +class compressed_pair<T, T> + : private details::compressed_pair_imp<T, T, + ::boost::details::compressed_pair_switch< + T, + T, + ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value, + ::boost::is_empty<T>::value, + ::boost::is_empty<T>::value>::value> +{ +private: + typedef details::compressed_pair_imp<T, T, + ::boost::details::compressed_pair_switch< + T, + T, + ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value, + ::boost::is_empty<T>::value, + ::boost::is_empty<T>::value>::value> base; +public: + typedef T first_type; + typedef T second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair() : base() {} + compressed_pair(first_param_type x, second_param_type y) : base(x, y) {} +#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) + explicit +#endif + compressed_pair(first_param_type x) : base(x) {} + + first_reference first() {return base::first();} + first_const_reference first() const {return base::first();} + + second_reference second() {return base::second();} + second_const_reference second() const {return base::second();} + + void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); } +}; + +template <class T1, class T2> +inline +void +swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y) +{ + x.swap(y); +} + +} // boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP + diff --git a/boost/detail/container_fwd.hpp b/boost/detail/container_fwd.hpp new file mode 100644 index 0000000000..7df7ccbb94 --- /dev/null +++ b/boost/detail/container_fwd.hpp @@ -0,0 +1,159 @@ + +// Copyright 2005-2011 Daniel James. +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Note: if you change this include guard, you also need to change +// container_fwd_compile_fail.cpp +#if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP) +#define BOOST_DETAIL_CONTAINER_FWD_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) && \ + !defined(BOOST_DETAIL_TEST_CONFIG_ONLY) +# pragma once +#endif + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +//////////////////////////////////////////////////////////////////////////////// +// // +// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to // +// forward declare standard containers. // +// // +//////////////////////////////////////////////////////////////////////////////// + +#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD) +# if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) + // STLport +# define BOOST_DETAIL_NO_CONTAINER_FWD +# elif defined(__LIBCOMO__) + // Comeau STL: +# define BOOST_DETAIL_NO_CONTAINER_FWD +# elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) + // Rogue Wave library: +# define BOOST_DETAIL_NO_CONTAINER_FWD +# elif defined(_LIBCPP_VERSION) + // libc++ +# define BOOST_DETAIL_NO_CONTAINER_FWD +# elif defined(__GLIBCPP__) || defined(__GLIBCXX__) + // GNU libstdc++ 3 + // + // Disable forwarding for all recent versions, as the library has a + // versioned namespace mode, and I don't know how to detect it. +# if __GLIBCXX__ >= 20070513 \ + || defined(_GLIBCXX_DEBUG) \ + || defined(_GLIBCXX_PARALLEL) \ + || defined(_GLIBCXX_PROFILE) +# define BOOST_DETAIL_NO_CONTAINER_FWD +# else +# if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530 +# define BOOST_CONTAINER_FWD_COMPLEX_STRUCT +# endif +# endif +# elif defined(__STL_CONFIG_H) + // generic SGI STL + // + // Forward declaration seems to be okay, but it has a couple of odd + // implementations. +# define BOOST_CONTAINER_FWD_BAD_BITSET +# if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG) +# define BOOST_CONTAINER_FWD_BAD_DEQUE +# endif +# elif defined(__MSL_CPP__) + // MSL standard lib: +# define BOOST_DETAIL_NO_CONTAINER_FWD +# elif defined(__IBMCPP__) + // The default VACPP std lib, forward declaration seems to be fine. +# elif defined(MSIPL_COMPILE_H) + // Modena C++ standard library +# define BOOST_DETAIL_NO_CONTAINER_FWD +# elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) + // Dinkumware Library (this has to appear after any possible replacement + // libraries) +# else +# define BOOST_DETAIL_NO_CONTAINER_FWD +# endif +#endif + +// BOOST_DETAIL_TEST_* macros are for testing only +// and shouldn't be relied upon. But you can use +// BOOST_DETAIL_NO_CONTAINER_FWD to prevent forward +// declaration of containers. + +#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY) + +#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \ + !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD) + +#include <deque> +#include <list> +#include <vector> +#include <map> +#include <set> +#include <bitset> +#include <string> +#include <complex> + +#else + +#include <cstddef> + +#if defined(BOOST_CONTAINER_FWD_BAD_DEQUE) +#include <deque> +#endif + +#if defined(BOOST_CONTAINER_FWD_BAD_BITSET) +#include <bitset> +#endif + +#if defined(BOOST_MSVC) +#pragma warning(push) +#pragma warning(disable:4099) // struct/class mismatch in fwd declarations +#endif + +namespace std +{ + template <class T> class allocator; + template <class charT, class traits, class Allocator> class basic_string; + +#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) + template <class charT> struct string_char_traits; +#else + template <class charT> struct char_traits; +#endif + +#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT) + template <class T> struct complex; +#else + template <class T> class complex; +#endif + +#if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE) + template <class T, class Allocator> class deque; +#endif + + template <class T, class Allocator> class list; + template <class T, class Allocator> class vector; + template <class Key, class T, class Compare, class Allocator> class map; + template <class Key, class T, class Compare, class Allocator> + class multimap; + template <class Key, class Compare, class Allocator> class set; + template <class Key, class Compare, class Allocator> class multiset; + +#if !defined(BOOST_CONTAINER_FWD_BAD_BITSET) + template <size_t N> class bitset; +#endif + template <class T1, class T2> struct pair; +} + +#if defined(BOOST_MSVC) +#pragma warning(pop) +#endif + +#endif // BOOST_DETAIL_NO_CONTAINER_FWD && + // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD) + +#endif // BOOST_DETAIL_TEST_CONFIG_ONLY + +#endif diff --git a/boost/detail/dynamic_bitset.hpp b/boost/detail/dynamic_bitset.hpp new file mode 100644 index 0000000000..281aa55cd6 --- /dev/null +++ b/boost/detail/dynamic_bitset.hpp @@ -0,0 +1,229 @@ +// ----------------------------------------------------------- +// +// Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek +// Copyright (c) 2003-2006, 2008 Gennaro Prota +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// ----------------------------------------------------------- + +#ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP +#define BOOST_DETAIL_DYNAMIC_BITSET_HPP + +#include <cstddef> +#include "boost/config.hpp" +#include "boost/detail/workaround.hpp" + + +namespace boost { + + namespace detail { + namespace dynamic_bitset_impl { + + // Gives (read-)access to the object representation + // of an object of type T (3.9p4). CANNOT be used + // on a base sub-object + // + template <typename T> + inline const unsigned char * object_representation (T* p) + { + return static_cast<const unsigned char *>(static_cast<const void *>(p)); + } + + template<typename T, int amount, int width /* = default */> + struct shifter + { + static void left_shift(T & v) { + amount >= width ? (v = 0) + : (v >>= BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(amount)); + } + }; + + // ------- count function implementation -------------- + + typedef unsigned char byte_type; + + // These two entities + // + // enum mode { access_by_bytes, access_by_blocks }; + // template <mode> struct mode_to_type {}; + // + // were removed, since the regression logs (as of 24 Aug 2008) + // showed that several compilers had troubles with recognizing + // + // const mode m = access_by_bytes + // + // as a constant expression + // + // * So, we'll use bool, instead of enum *. + // + template <bool value> + struct value_to_type + { + value_to_type() {} + }; + const bool access_by_bytes = true; + const bool access_by_blocks = false; + + + // the table: wrapped in a class template, so + // that it is only instantiated if/when needed + // + template <bool dummy_name = true> + struct count_table { static const byte_type table[]; }; + + template <> + struct count_table<false> { /* no table */ }; + + + const unsigned int table_width = 8; + template <bool b> + const byte_type count_table<b>::table[] = + { + // Automatically generated by GPTableGen.exe v.1.0 + // + 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 + }; + + + // overload for access by bytes + // + + template <typename Iterator> + inline std::size_t do_count(Iterator first, std::size_t length, + int /*dummy param*/, + value_to_type<access_by_bytes>* ) + { + std::size_t num = 0; + if (length) + { + const byte_type * p = object_representation(&*first); + length *= sizeof(*first); + + do { + num += count_table<>::table[*p]; + ++p; + --length; + + } while (length); + } + + return num; + } + + + // overload for access by blocks + // + template <typename Iterator, typename ValueType> + inline std::size_t do_count(Iterator first, std::size_t length, ValueType, + value_to_type<access_by_blocks>*) + { + std::size_t num = 0; + while (length){ + + ValueType value = *first; + while (value) { + num += count_table<>::table[value & ((1u<<table_width) - 1)]; + value >>= table_width; + } + + ++first; + --length; + } + + return num; + } + + // ------------------------------------------------------- + + + // Some library implementations simply return a dummy + // value such as + // + // size_type(-1) / sizeof(T) + // + // from vector<>::max_size. This tries to get more + // meaningful info. + // + template <typename T> + typename T::size_type vector_max_size_workaround(const T & v) { + + typedef typename T::allocator_type allocator_type; + + const typename allocator_type::size_type alloc_max = + v.get_allocator().max_size(); + const typename T::size_type container_max = v.max_size(); + + return alloc_max < container_max? + alloc_max : + container_max; + } + + // for static_asserts + template <typename T> + struct allowed_block_type { + enum { value = T(-1) > 0 }; // ensure T has no sign + }; + + template <> + struct allowed_block_type<bool> { + enum { value = false }; + }; + + + template <typename T> + struct is_numeric { + enum { value = false }; + }; + +# define BOOST_dynamic_bitset_is_numeric(x) \ + template<> \ + struct is_numeric< x > { \ + enum { value = true }; \ + } /**/ + + BOOST_dynamic_bitset_is_numeric(bool); + BOOST_dynamic_bitset_is_numeric(char); + +#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) + BOOST_dynamic_bitset_is_numeric(wchar_t); +#endif + + BOOST_dynamic_bitset_is_numeric(signed char); + BOOST_dynamic_bitset_is_numeric(short int); + BOOST_dynamic_bitset_is_numeric(int); + BOOST_dynamic_bitset_is_numeric(long int); + + BOOST_dynamic_bitset_is_numeric(unsigned char); + BOOST_dynamic_bitset_is_numeric(unsigned short); + BOOST_dynamic_bitset_is_numeric(unsigned int); + BOOST_dynamic_bitset_is_numeric(unsigned long); + +#if defined(BOOST_HAS_LONG_LONG) + BOOST_dynamic_bitset_is_numeric(::boost::long_long_type); + BOOST_dynamic_bitset_is_numeric(::boost::ulong_long_type); +#endif + + // intentionally omitted + //BOOST_dynamic_bitset_is_numeric(float); + //BOOST_dynamic_bitset_is_numeric(double); + //BOOST_dynamic_bitset_is_numeric(long double); + +#undef BOOST_dynamic_bitset_is_numeric + + } // dynamic_bitset_impl + } // namespace detail + +} // namespace boost + +#endif // include guard + diff --git a/boost/detail/endian.hpp b/boost/detail/endian.hpp new file mode 100644 index 0000000000..98c870ca2f --- /dev/null +++ b/boost/detail/endian.hpp @@ -0,0 +1,78 @@ +// Copyright 2005 Caleb Epstein +// Copyright 2006 John Maddock +// Copyright 2010 Rene Rivera +// Distributed under the Boost Software License, Version 1.0. (See accompany- +// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +/* + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/* + * Copyright notice reproduced from <boost/detail/limits.hpp>, from + * which this code was originally taken. + * + * Modified by Caleb Epstein to use <endian.h> with GNU libc and to + * defined the BOOST_ENDIAN macro. + */ + +#ifndef BOOST_DETAIL_ENDIAN_HPP +#define BOOST_DETAIL_ENDIAN_HPP + +// GNU libc offers the helpful header <endian.h> which defines +// __BYTE_ORDER + +#if defined (__GLIBC__) +# include <endian.h> +# if (__BYTE_ORDER == __LITTLE_ENDIAN) +# define BOOST_LITTLE_ENDIAN +# elif (__BYTE_ORDER == __BIG_ENDIAN) +# define BOOST_BIG_ENDIAN +# elif (__BYTE_ORDER == __PDP_ENDIAN) +# define BOOST_PDP_ENDIAN +# else +# error Unknown machine endianness detected. +# endif +# define BOOST_BYTE_ORDER __BYTE_ORDER +#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \ + defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) || \ + defined(_STLP_BIG_ENDIAN) && !defined(_STLP_LITTLE_ENDIAN) +# define BOOST_BIG_ENDIAN +# define BOOST_BYTE_ORDER 4321 +#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \ + defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) || \ + defined(_STLP_LITTLE_ENDIAN) && !defined(_STLP_BIG_ENDIAN) +# define BOOST_LITTLE_ENDIAN +# define BOOST_BYTE_ORDER 1234 +#elif defined(__sparc) || defined(__sparc__) \ + || defined(_POWER) || defined(__powerpc__) \ + || defined(__ppc__) || defined(__hpux) || defined(__hppa) \ + || defined(_MIPSEB) || defined(_POWER) \ + || defined(__s390__) +# define BOOST_BIG_ENDIAN +# define BOOST_BYTE_ORDER 4321 +#elif defined(__i386__) || defined(__alpha__) \ + || defined(__ia64) || defined(__ia64__) \ + || defined(_M_IX86) || defined(_M_IA64) \ + || defined(_M_ALPHA) || defined(__amd64) \ + || defined(__amd64__) || defined(_M_AMD64) \ + || defined(__x86_64) || defined(__x86_64__) \ + || defined(_M_X64) || defined(__bfin__) + +# define BOOST_LITTLE_ENDIAN +# define BOOST_BYTE_ORDER 1234 +#else +# error The file boost/detail/endian.hpp needs to be set up for your CPU type. +#endif + + +#endif diff --git a/boost/detail/fenv.hpp b/boost/detail/fenv.hpp new file mode 100644 index 0000000000..f048706416 --- /dev/null +++ b/boost/detail/fenv.hpp @@ -0,0 +1,74 @@ +/*============================================================================= + Copyright (c) 2010 Bryce Lelbach + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/config.hpp> + +#if defined(BOOST_NO_FENV_H) + #error This platform does not have a floating point environment +#endif + +#if !defined(BOOST_DETAIL_FENV_HPP) +#define BOOST_DETAIL_FENV_HPP + +/* If we're using clang + glibc, we have to get hacky. + * See http://llvm.org/bugs/show_bug.cgi?id=6907 */ +#if defined(__clang__) && (__clang_major__ < 3) && \ + defined(__GNU_LIBRARY__) && /* up to version 5 */ \ + defined(__GLIBC__) && /* version 6 + */ \ + !defined(_FENV_H) + #define _FENV_H + + #include <features.h> + #include <bits/fenv.h> + + extern "C" { + extern int fegetexceptflag (fexcept_t*, int) __THROW; + extern int fesetexceptflag (__const fexcept_t*, int) __THROW; + extern int feclearexcept (int) __THROW; + extern int feraiseexcept (int) __THROW; + extern int fetestexcept (int) __THROW; + extern int fegetround (void) __THROW; + extern int fesetround (int) __THROW; + extern int fegetenv (fenv_t*) __THROW; + extern int fesetenv (__const fenv_t*) __THROW; + extern int feupdateenv (__const fenv_t*) __THROW; + extern int feholdexcept (fenv_t*) __THROW; + + #ifdef __USE_GNU + extern int feenableexcept (int) __THROW; + extern int fedisableexcept (int) __THROW; + extern int fegetexcept (void) __THROW; + #endif + } + + namespace std { namespace tr1 { + using ::fenv_t; + using ::fexcept_t; + using ::fegetexceptflag; + using ::fesetexceptflag; + using ::feclearexcept; + using ::feraiseexcept; + using ::fetestexcept; + using ::fegetround; + using ::fesetround; + using ::fegetenv; + using ::fesetenv; + using ::feupdateenv; + using ::feholdexcept; + } } + +#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */ + #if defined(__SUNPRO_CC) /* lol suncc */ + #include <stdio.h> + #endif + + #include <fenv.h> + +#endif + +#endif /* BOOST_DETAIL_FENV_HPP */ + diff --git a/boost/detail/has_default_constructor.hpp b/boost/detail/has_default_constructor.hpp new file mode 100644 index 0000000000..319b30abcd --- /dev/null +++ b/boost/detail/has_default_constructor.hpp @@ -0,0 +1,29 @@ + +// (C) Copyright Matthias Troyerk 2006. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED + +#include <boost/type_traits/has_trivial_constructor.hpp> + +namespace boost { namespace detail { + +/// type trait to check for a default constructor +/// +/// The default implementation just checks for a trivial constructor. +/// Using some compiler magic it might be possible to provide a better default + +template <class T> +struct has_default_constructor + : public has_trivial_constructor<T> +{}; + +} } // namespace boost::detail + + +#endif // BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED diff --git a/boost/detail/identifier.hpp b/boost/detail/identifier.hpp new file mode 100644 index 0000000000..688a664f7d --- /dev/null +++ b/boost/detail/identifier.hpp @@ -0,0 +1,89 @@ +// boost/identifier.hpp ----------------------------------------------------// + +// Copyright Beman Dawes 2006 + +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See documentation at http://www.boost.org/libs/utility + +#ifndef BOOST_IDENTIFIER_HPP +#define BOOST_IDENTIFIER_HPP + +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_base_of.hpp> +#include <iosfwd> + +namespace boost +{ + namespace detail + { + // class template identifier ---------------------------------------------// + + // Always used as a base class so that different instantiations result in + // different class types even if instantiated with the same value type T. + + // Expected usage is that T is often an integer type, best passed by + // value. There is no reason why T can't be a possibly larger class such as + // std::string, best passed by const reference. + + // This implementation uses pass by value, based on expected common uses. + + template <typename T, typename D> + class identifier + { + public: + typedef T value_type; + + const value_type value() const { return m_value; } + void assign( value_type v ) { m_value = v; } + + bool operator==( const D & rhs ) const { return m_value == rhs.m_value; } + bool operator!=( const D & rhs ) const { return m_value != rhs.m_value; } + bool operator< ( const D & rhs ) const { return m_value < rhs.m_value; } + bool operator<=( const D & rhs ) const { return m_value <= rhs.m_value; } + bool operator> ( const D & rhs ) const { return m_value > rhs.m_value; } + bool operator>=( const D & rhs ) const { return m_value >= rhs.m_value; } + + typedef void (*unspecified_bool_type)(D); // without the D, unspecified_bool_type + static void unspecified_bool_true(D){} // conversion allows relational operators + // between different identifier types + + operator unspecified_bool_type() const { return m_value == value_type() ? 0 : unspecified_bool_true; } + bool operator!() const { return m_value == value_type(); } + + // constructors are protected so that class can only be used as a base class + protected: + identifier() {} + explicit identifier( value_type v ) : m_value(v) {} + + #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // 1300 == VC++ 7.0 bug workaround + private: + #endif + T m_value; + }; + + //#ifndef BOOST_NO_SFINAE + + // template <class Ostream, class Id> + // typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, + // Ostream & >::type operator<<( Ostream & os, const Id & id ) + // { + // return os << id.value(); + // } + + // template <class Istream, class Id> + // typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, + // Istream & >::type operator>>( Istream & is, Id & id ) + // { + // typename Id::value_type v; + // is >> v; + // id.value( v ); + // return is; + // } + //#endif + + } // namespace detail +} // namespace boost + +#endif // BOOST_IDENTIFIER_HPP diff --git a/boost/detail/indirect_traits.hpp b/boost/detail/indirect_traits.hpp new file mode 100644 index 0000000000..f9c0cd6a04 --- /dev/null +++ b/boost/detail/indirect_traits.hpp @@ -0,0 +1,487 @@ +// Copyright David Abrahams 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef INDIRECT_TRAITS_DWA2002131_HPP +# define INDIRECT_TRAITS_DWA2002131_HPP +# include <boost/type_traits/is_function.hpp> +# include <boost/type_traits/is_reference.hpp> +# include <boost/type_traits/is_pointer.hpp> +# include <boost/type_traits/is_class.hpp> +# include <boost/type_traits/is_const.hpp> +# include <boost/type_traits/is_volatile.hpp> +# include <boost/type_traits/is_member_function_pointer.hpp> +# include <boost/type_traits/is_member_pointer.hpp> +# include <boost/type_traits/remove_cv.hpp> +# include <boost/type_traits/remove_reference.hpp> +# include <boost/type_traits/remove_pointer.hpp> + +# include <boost/type_traits/detail/ice_and.hpp> +# include <boost/detail/workaround.hpp> + +# include <boost/mpl/eval_if.hpp> +# include <boost/mpl/if.hpp> +# include <boost/mpl/bool.hpp> +# include <boost/mpl/and.hpp> +# include <boost/mpl/not.hpp> +# include <boost/mpl/aux_/lambda_support.hpp> + +# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include <boost/detail/is_function_ref_tester.hpp> +# endif + +namespace boost { namespace detail { + +namespace indirect_traits { + +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template <class T> +struct is_reference_to_const : mpl::false_ +{ +}; + +template <class T> +struct is_reference_to_const<T const&> : mpl::true_ +{ +}; + +# if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround +template<class T> +struct is_reference_to_const<T const volatile&> : mpl::true_ +{ +}; +# endif + +template <class T> +struct is_reference_to_function : mpl::false_ +{ +}; + +template <class T> +struct is_reference_to_function<T&> : is_function<T> +{ +}; + +template <class T> +struct is_pointer_to_function : mpl::false_ +{ +}; + +// There's no such thing as a pointer-to-cv-function, so we don't need +// specializations for those +template <class T> +struct is_pointer_to_function<T*> : is_function<T> +{ +}; + +template <class T> +struct is_reference_to_member_function_pointer_impl : mpl::false_ +{ +}; + +template <class T> +struct is_reference_to_member_function_pointer_impl<T&> + : is_member_function_pointer<typename remove_cv<T>::type> +{ +}; + + +template <class T> +struct is_reference_to_member_function_pointer + : is_reference_to_member_function_pointer_impl<T> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T)) +}; + +template <class T> +struct is_reference_to_function_pointer_aux + : mpl::and_< + is_reference<T> + , is_pointer_to_function< + typename remove_cv< + typename remove_reference<T>::type + >::type + > + > +{ + // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those +}; + +template <class T> +struct is_reference_to_function_pointer + : mpl::if_< + is_reference_to_function<T> + , mpl::false_ + , is_reference_to_function_pointer_aux<T> + >::type +{ +}; + +template <class T> +struct is_reference_to_non_const + : mpl::and_< + is_reference<T> + , mpl::not_< + is_reference_to_const<T> + > + > +{ +}; + +template <class T> +struct is_reference_to_volatile : mpl::false_ +{ +}; + +template <class T> +struct is_reference_to_volatile<T volatile&> : mpl::true_ +{ +}; + +# if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround +template <class T> +struct is_reference_to_volatile<T const volatile&> : mpl::true_ +{ +}; +# endif + + +template <class T> +struct is_reference_to_pointer : mpl::false_ +{ +}; + +template <class T> +struct is_reference_to_pointer<T*&> : mpl::true_ +{ +}; + +template <class T> +struct is_reference_to_pointer<T* const&> : mpl::true_ +{ +}; + +template <class T> +struct is_reference_to_pointer<T* volatile&> : mpl::true_ +{ +}; + +template <class T> +struct is_reference_to_pointer<T* const volatile&> : mpl::true_ +{ +}; + +template <class T> +struct is_reference_to_class + : mpl::and_< + is_reference<T> + , is_class< + typename remove_cv< + typename remove_reference<T>::type + >::type + > + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T)) +}; + +template <class T> +struct is_pointer_to_class + : mpl::and_< + is_pointer<T> + , is_class< + typename remove_cv< + typename remove_pointer<T>::type + >::type + > + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T)) +}; + +# else + +using namespace boost::detail::is_function_ref_tester_; + +typedef char (&inner_yes_type)[3]; +typedef char (&inner_no_type)[2]; +typedef char (&outer_no_type)[1]; + +template <typename V> +struct is_const_help +{ + typedef typename mpl::if_< + is_const<V> + , inner_yes_type + , inner_no_type + >::type type; +}; + +template <typename V> +struct is_volatile_help +{ + typedef typename mpl::if_< + is_volatile<V> + , inner_yes_type + , inner_no_type + >::type type; +}; + +template <typename V> +struct is_pointer_help +{ + typedef typename mpl::if_< + is_pointer<V> + , inner_yes_type + , inner_no_type + >::type type; +}; + +template <typename V> +struct is_class_help +{ + typedef typename mpl::if_< + is_class<V> + , inner_yes_type + , inner_no_type + >::type type; +}; + +template <class T> +struct is_reference_to_function_aux +{ + static T t; + BOOST_STATIC_CONSTANT( + bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type)); + typedef mpl::bool_<value> type; + }; + +template <class T> +struct is_reference_to_function + : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type +{ +}; + +template <class T> +struct is_pointer_to_function_aux +{ + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type)); + typedef mpl::bool_<value> type; +}; + +template <class T> +struct is_pointer_to_function + : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T)) +}; + +struct false_helper1 +{ + template <class T> + struct apply : mpl::false_ + { + }; +}; + +template <typename V> +typename is_const_help<V>::type reference_to_const_helper(V&); +outer_no_type +reference_to_const_helper(...); + +struct true_helper1 +{ + template <class T> + struct apply + { + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type)); + typedef mpl::bool_<value> type; + }; +}; + +template <bool ref = true> +struct is_reference_to_const_helper1 : true_helper1 +{ +}; + +template <> +struct is_reference_to_const_helper1<false> : false_helper1 +{ +}; + + +template <class T> +struct is_reference_to_const + : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T> +{ +}; + + +template <bool ref = true> +struct is_reference_to_non_const_helper1 +{ + template <class T> + struct apply + { + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type)); + + typedef mpl::bool_<value> type; + }; +}; + +template <> +struct is_reference_to_non_const_helper1<false> : false_helper1 +{ +}; + + +template <class T> +struct is_reference_to_non_const + : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T)) +}; + + +template <typename V> +typename is_volatile_help<V>::type reference_to_volatile_helper(V&); +outer_no_type +reference_to_volatile_helper(...); + +template <bool ref = true> +struct is_reference_to_volatile_helper1 +{ + template <class T> + struct apply + { + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type)); + typedef mpl::bool_<value> type; + }; +}; + +template <> +struct is_reference_to_volatile_helper1<false> : false_helper1 +{ +}; + + +template <class T> +struct is_reference_to_volatile + : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T> +{ +}; + +template <typename V> +typename is_pointer_help<V>::type reference_to_pointer_helper(V&); +outer_no_type reference_to_pointer_helper(...); + +template <class T> +struct reference_to_pointer_impl +{ + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type)) + ); + + typedef mpl::bool_<value> type; +}; + +template <class T> +struct is_reference_to_pointer + : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T)) +}; + +template <class T> +struct is_reference_to_function_pointer + : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T)) +}; + + +template <class T> +struct is_member_function_pointer_help + : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type> +{}; + +template <typename V> +typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&); +outer_no_type member_function_pointer_helper(...); + +template <class T> +struct is_pointer_to_member_function_aux +{ + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type)); + typedef mpl::bool_<value> type; +}; + +template <class T> +struct is_reference_to_member_function_pointer + : mpl::if_< + is_reference<T> + , is_pointer_to_member_function_aux<T> + , mpl::bool_<false> + >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T)) +}; + +template <typename V> +typename is_class_help<V>::type reference_to_class_helper(V const volatile&); +outer_no_type reference_to_class_helper(...); + +template <class T> +struct is_reference_to_class +{ + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = (is_reference<T>::value + & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type))) + ); + typedef mpl::bool_<value> type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T)) +}; + +template <typename V> +typename is_class_help<V>::type pointer_to_class_helper(V const volatile*); +outer_no_type pointer_to_class_helper(...); + +template <class T> +struct is_pointer_to_class +{ + static T t; + BOOST_STATIC_CONSTANT( + bool, value + = (is_pointer<T>::value + && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type)) + ); + typedef mpl::bool_<value> type; +}; +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} + +using namespace indirect_traits; + +}} // namespace boost::python::detail + +#endif // INDIRECT_TRAITS_DWA2002131_HPP diff --git a/boost/detail/interlocked.hpp b/boost/detail/interlocked.hpp new file mode 100644 index 0000000000..1802e3411d --- /dev/null +++ b/boost/detail/interlocked.hpp @@ -0,0 +1,163 @@ +#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED +#define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/interlocked.hpp +// +// Copyright 2005 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#include <boost/config.hpp> + +#if defined( BOOST_USE_WINDOWS_H ) + +# include <windows.h> + +# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement +# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange +# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange +# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer +# define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer + +#elif defined(_WIN32_WCE) + +// under Windows CE we still have old-style Interlocked* functions + +extern "C" long __cdecl InterlockedIncrement( long* ); +extern "C" long __cdecl InterlockedDecrement( long* ); +extern "C" long __cdecl InterlockedCompareExchange( long*, long, long ); +extern "C" long __cdecl InterlockedExchange( long*, long ); +extern "C" long __cdecl InterlockedExchangeAdd( long*, long ); + +# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement +# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange +# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange +# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd + +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \ + ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare))) +# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \ + ((void*)BOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange))) + +#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN ) + +#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600 + +#include <intrin.h> + +#elif defined( __CLRCALL_PURE_OR_CDECL ) + +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long ); + +#else + +extern "C" long __cdecl _InterlockedIncrement( long volatile * ); +extern "C" long __cdecl _InterlockedDecrement( long volatile * ); +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); + +#endif + +# pragma intrinsic( _InterlockedIncrement ) +# pragma intrinsic( _InterlockedDecrement ) +# pragma intrinsic( _InterlockedCompareExchange ) +# pragma intrinsic( _InterlockedExchange ) +# pragma intrinsic( _InterlockedExchangeAdd ) + +# if defined(_M_IA64) || defined(_M_AMD64) + +extern "C" void* __cdecl _InterlockedCompareExchangePointer( void* volatile *, void*, void* ); +extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* ); + +# pragma intrinsic( _InterlockedCompareExchangePointer ) +# pragma intrinsic( _InterlockedExchangePointer ) + +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer +# define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer + +# else + +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \ + ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare))) +# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \ + ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange))) + +# endif + +# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ ) + +#if defined(__MINGW64__) +#define BOOST_INTERLOCKED_IMPORT +#else +#define BOOST_INTERLOCKED_IMPORT __declspec(dllimport) +#endif + + +namespace boost +{ + +namespace detail +{ + +extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * ); +extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * ); +extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long ); +extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long ); +extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long ); + +# if defined(_M_IA64) || defined(_M_AMD64) +extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* ); +extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* ); +# endif + +} // namespace detail + +} // namespace boost + +# define BOOST_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement +# define BOOST_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange +# define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange +# define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd + +# if defined(_M_IA64) || defined(_M_AMD64) +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::boost::detail::InterlockedCompareExchangePointer +# define BOOST_INTERLOCKED_EXCHANGE_POINTER ::boost::detail::InterlockedExchangePointer +# else +# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \ + ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare))) +# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \ + ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange))) +# endif + +#else + +# error "Interlocked intrinsics not available" + +#endif + +#endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED diff --git a/boost/detail/is_function_ref_tester.hpp b/boost/detail/is_function_ref_tester.hpp new file mode 100644 index 0000000000..5f367ea818 --- /dev/null +++ b/boost/detail/is_function_ref_tester.hpp @@ -0,0 +1,135 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED +#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED + +#include "boost/type_traits/detail/yes_no_type.hpp" +#include "boost/type_traits/config.hpp" + +#if defined(BOOST_TT_PREPROCESSING_MODE) +# include "boost/preprocessor/iterate.hpp" +# include "boost/preprocessor/enum_params.hpp" +# include "boost/preprocessor/comma_if.hpp" +#endif + +namespace boost { +namespace detail { +namespace is_function_ref_tester_ { + +template <class T> +boost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...); + +#if !defined(BOOST_TT_PREPROCESSING_MODE) +// preprocessor-generated part, don't edit by hand! + +template <class R> +boost::type_traits::yes_type is_function_ref_tester(R (&)(), int); + +template <class R,class T0 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int); + +template <class R,class T0,class T1 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int); + +template <class R,class T0,class T1,class T2 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int); + +template <class R,class T0,class T1,class T2,class T3 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int); + +template <class R,class T0,class T1,class T2,class T3,class T4 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int); + +template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24 > +boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int); + +#else + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, 25, "boost/type_traits/detail/is_function_ref_tester.hpp")) +#include BOOST_PP_ITERATE() + +#endif // BOOST_TT_PREPROCESSING_MODE + +} // namespace detail +} // namespace python +} // namespace boost + +#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED + +///// iteration + +#else +#define i BOOST_PP_FRAME_ITERATION(1) + +template <class R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T) > +boost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int); + +#undef i +#endif // BOOST_PP_IS_ITERATING diff --git a/boost/detail/is_incrementable.hpp b/boost/detail/is_incrementable.hpp new file mode 100644 index 0000000000..e7ef9dc625 --- /dev/null +++ b/boost/detail/is_incrementable.hpp @@ -0,0 +1,134 @@ +// Copyright David Abrahams 2004. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef IS_INCREMENTABLE_DWA200415_HPP +# define IS_INCREMENTABLE_DWA200415_HPP + +# include <boost/type_traits/detail/template_arity_spec.hpp> +# include <boost/type_traits/remove_cv.hpp> +# include <boost/mpl/aux_/lambda_support.hpp> +# include <boost/mpl/bool.hpp> +# include <boost/detail/workaround.hpp> + +// Must be the last include +# include <boost/type_traits/detail/bool_trait_def.hpp> + +namespace boost { namespace detail { + +// is_incrementable<T> metafunction +// +// Requires: Given x of type T&, if the expression ++x is well-formed +// it must have complete type; otherwise, it must neither be ambiguous +// nor violate access. + +// This namespace ensures that ADL doesn't mess things up. +namespace is_incrementable_ +{ + // a type returned from operator++ when no increment is found in the + // type's own namespace + struct tag {}; + + // any soaks up implicit conversions and makes the following + // operator++ less-preferred than any other such operator that + // might be found via ADL. + struct any { template <class T> any(T const&); }; + + // This is a last-resort operator++ for when none other is found +# if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2 + +} + +namespace is_incrementable_2 +{ + is_incrementable_::tag operator++(is_incrementable_::any const&); + is_incrementable_::tag operator++(is_incrementable_::any const&,int); +} +using namespace is_incrementable_2; + +namespace is_incrementable_ +{ + +# else + + tag operator++(any const&); + tag operator++(any const&,int); + +# endif + +# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ + || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_comma(a,b) (a) +# else + // In case an operator++ is found that returns void, we'll use ++x,0 + tag operator,(tag,int); +# define BOOST_comma(a,b) (a,b) +# endif + +# if defined(BOOST_MSVC) +# pragma warning(push) +# pragma warning(disable:4913) // Warning about operator, +# endif + + // two check overloads help us identify which operator++ was picked + char (& check_(tag) )[2]; + + template <class T> + char check_(T const&); + + + template <class T> + struct impl + { + static typename boost::remove_cv<T>::type& x; + + BOOST_STATIC_CONSTANT( + bool + , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1 + ); + }; + + template <class T> + struct postfix_impl + { + static typename boost::remove_cv<T>::type& x; + + BOOST_STATIC_CONSTANT( + bool + , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1 + ); + }; + +# if defined(BOOST_MSVC) +# pragma warning(pop) +# endif + +} + +# undef BOOST_comma + +template<typename T> +struct is_incrementable +BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value) +{ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::impl<T>::value) + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T)) +}; + +template<typename T> +struct is_postfix_incrementable +BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value) +{ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::postfix_impl<T>::value) + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T)) +}; + +} // namespace detail + +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_incrementable) +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_postfix_incrementable) + +} // namespace boost + +# include <boost/type_traits/detail/bool_trait_undef.hpp> + +#endif // IS_INCREMENTABLE_DWA200415_HPP diff --git a/boost/detail/is_sorted.hpp b/boost/detail/is_sorted.hpp new file mode 100644 index 0000000000..5ab32e5c59 --- /dev/null +++ b/boost/detail/is_sorted.hpp @@ -0,0 +1,56 @@ +/*============================================================================== + Copyright (c) 2010-2011 Bryce Lelbach + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ + +#ifndef BOOST_DETAIL_SORTED_HPP +#define BOOST_DETAIL_SORTED_HPP + +#include <boost/detail/iterator.hpp> + +#include <functional> + +namespace boost { +namespace detail { + +template<class Iterator, class Comp> +inline Iterator is_sorted_until (Iterator first, Iterator last, Comp c) { + if (first == last) + return last; + + Iterator it = first; ++it; + + for (; it != last; first = it, ++it) + if (c(*it, *first)) + return it; + + return it; +} + +template<class Iterator> +inline Iterator is_sorted_until (Iterator first, Iterator last) { + typedef typename boost::detail::iterator_traits<Iterator>::value_type + value_type; + + typedef std::less<value_type> c; + + return ::boost::detail::is_sorted_until(first, last, c()); +} + +template<class Iterator, class Comp> +inline bool is_sorted (Iterator first, Iterator last, Comp c) { + return ::boost::detail::is_sorted_until(first, last, c) == last; +} + +template<class Iterator> +inline bool is_sorted (Iterator first, Iterator last) { + return ::boost::detail::is_sorted_until(first, last) == last; +} + +} // detail +} // boost + +#endif // BOOST_DETAIL_SORTED_HPP + diff --git a/boost/detail/is_xxx.hpp b/boost/detail/is_xxx.hpp new file mode 100644 index 0000000000..cb64fb32b8 --- /dev/null +++ b/boost/detail/is_xxx.hpp @@ -0,0 +1,61 @@ +// Copyright David Abrahams 2005. Distributed under the Boost +// Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_DETAIL_IS_XXX_DWA20051011_HPP +# define BOOST_DETAIL_IS_XXX_DWA20051011_HPP + +# include <boost/config.hpp> +# include <boost/mpl/bool.hpp> +# include <boost/preprocessor/enum_params.hpp> + +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# include <boost/type_traits/is_reference.hpp> +# include <boost/type_traits/add_reference.hpp> + +# define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs) \ +template <class X_> \ +struct is_##name \ +{ \ + typedef char yes; \ + typedef char (&no)[2]; \ + \ + static typename add_reference<X_>::type dummy; \ + \ + struct helpers \ + { \ + template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class U) > \ + static yes test( \ + qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, U) >&, int \ + ); \ + \ + template <class U> \ + static no test(U&, ...); \ + }; \ + \ + BOOST_STATIC_CONSTANT( \ + bool, value \ + = !is_reference<X_>::value \ + & (sizeof(helpers::test(dummy, 0)) == sizeof(yes))); \ + \ + typedef mpl::bool_<value> type; \ +}; + +# else + +# define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs) \ +template <class T> \ +struct is_##name : mpl::false_ \ +{ \ +}; \ + \ +template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) > \ +struct is_##name< \ + qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) > \ +> \ + : mpl::true_ \ +{ \ +}; + +# endif + +#endif // BOOST_DETAIL_IS_XXX_DWA20051011_HPP diff --git a/boost/detail/iterator.hpp b/boost/detail/iterator.hpp new file mode 100644 index 0000000000..5bb9c6269c --- /dev/null +++ b/boost/detail/iterator.hpp @@ -0,0 +1,494 @@ +// (C) Copyright David Abrahams 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Boost versions of +// +// std::iterator_traits<>::iterator_category +// std::iterator_traits<>::difference_type +// std::distance() +// +// ...for all compilers and iterators +// +// Additionally, if X is a pointer +// std::iterator_traits<X>::pointer + +// Otherwise, if partial specialization is supported or X is not a pointer +// std::iterator_traits<X>::value_type +// std::iterator_traits<X>::pointer +// std::iterator_traits<X>::reference +// +// See http://www.boost.org for most recent version including documentation. + +// Revision History +// 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams) +// 03 Mar 2001 - Put all implementation into namespace +// boost::detail::iterator_traits_. Some progress made on fixes +// for Intel compiler. (David Abrahams) +// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few +// places. (Jeremy Siek) +// 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and +// no_type from type_traits.hpp; stopped trying to remove_cv +// before detecting is_pointer, in honor of the new type_traits +// semantics. (David Abrahams) +// 13 Feb 2001 - Make it work with nearly all standard-conforming iterators +// under raw VC6. The one category remaining which will fail is +// that of iterators derived from std::iterator but not +// boost::iterator and which redefine difference_type. +// 11 Feb 2001 - Clean away code which can never be used (David Abrahams) +// 09 Feb 2001 - Always have a definition for each traits member, even if it +// can't be properly deduced. These will be incomplete types in +// some cases (undefined<void>), but it helps suppress MSVC errors +// elsewhere (David Abrahams) +// 07 Feb 2001 - Support for more of the traits members where possible, making +// this useful as a replacement for std::iterator_traits<T> when +// used as a default template parameter. +// 06 Feb 2001 - Removed useless #includes of standard library headers +// (David Abrahams) + +#ifndef ITERATOR_DWA122600_HPP_ +# define ITERATOR_DWA122600_HPP_ + +# include <boost/config.hpp> +# include <iterator> + +// STLPort 4.0 and betas have a bug when debugging is enabled and there is no +// partial specialization: instead of an iterator_category typedef, the standard +// container iterators have _Iterator_category. +// +// Also, whether debugging is enabled or not, there is a broken specialization +// of std::iterator<output_iterator_tag,void,void,void,void> which has no +// typedefs but iterator_category. +# if defined(__SGI_STL_PORT) + +# if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG) +# define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF +# endif + +# define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION + +# endif // STLPort <= 4.1b4 && no partial specialization + +# if !defined(BOOST_NO_STD_ITERATOR_TRAITS) \ + && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MSVC_STD_ITERATOR) + +namespace boost { namespace detail { + +// Define a new template so it can be specialized +template <class Iterator> +struct iterator_traits + : std::iterator_traits<Iterator> +{}; +using std::distance; + +}} // namespace boost::detail + +# else + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MSVC_STD_ITERATOR) + +// This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS + +namespace boost { namespace detail { + +// Rogue Wave Standard Library fools itself into thinking partial +// specialization is missing on some platforms (e.g. Sun), so fails to +// supply iterator_traits! +template <class Iterator> +struct iterator_traits +{ + typedef typename Iterator::value_type value_type; + typedef typename Iterator::reference reference; + typedef typename Iterator::pointer pointer; + typedef typename Iterator::difference_type difference_type; + typedef typename Iterator::iterator_category iterator_category; +}; + +template <class T> +struct iterator_traits<T*> +{ + typedef T value_type; + typedef T& reference; + typedef T* pointer; + typedef std::ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; + +template <class T> +struct iterator_traits<T const*> +{ + typedef T value_type; + typedef T const& reference; + typedef T const* pointer; + typedef std::ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; + +}} // namespace boost::detail + +# else + +# include <boost/type_traits/remove_const.hpp> +# include <boost/type_traits/detail/yes_no_type.hpp> +# include <boost/type_traits/is_pointer.hpp> + +# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include <boost/type_traits/is_same.hpp> +# include <boost/type_traits/remove_pointer.hpp> +# endif +# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION +# include <boost/type_traits/is_base_and_derived.hpp> +# endif + +# include <boost/mpl/if.hpp> +# include <boost/mpl/has_xxx.hpp> +# include <cstddef> + +// should be the last #include +# include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { namespace detail { + +BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type) +BOOST_MPL_HAS_XXX_TRAIT_DEF(reference) +BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer) +BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type) +BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category) + +// is_mutable_iterator -- +// +// A metafunction returning true iff T is a mutable iterator type +// with a nested value_type. Will only work portably with iterators +// whose operator* returns a reference, but that seems to be OK for +// the iterators supplied by Dinkumware. Some input iterators may +// compile-time if they arrive here, and if the compiler is strict +// about not taking the address of an rvalue. + +// This one detects ordinary mutable iterators - the result of +// operator* is convertible to the value_type. +template <class T> +type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*); + +// Since you can't take the address of an rvalue, the guts of +// is_mutable_iterator_impl will fail if we use &*t directly. This +// makes sure we can still work with non-lvalue iterators. +template <class T> T* mutable_iterator_lvalue_helper(T& x); +int mutable_iterator_lvalue_helper(...); + + +// This one detects output iterators such as ostream_iterator which +// return references to themselves. +template <class T> +type_traits::yes_type is_mutable_iterator_helper(T const*, T const*); + +type_traits::no_type is_mutable_iterator_helper(...); + +template <class T> +struct is_mutable_iterator_impl +{ + static T t; + + BOOST_STATIC_CONSTANT( + bool, value = sizeof( + detail::is_mutable_iterator_helper( + (T*)0 + , mutable_iterator_lvalue_helper(*t) // like &*t + )) + == sizeof(type_traits::yes_type) + ); +}; + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_mutable_iterator,T,::boost::detail::is_mutable_iterator_impl<T>::value) + + +// is_full_iterator_traits -- +// +// A metafunction returning true iff T has all the requisite nested +// types to satisfy the requirements for a fully-conforming +// iterator_traits implementation. +template <class T> +struct is_full_iterator_traits_impl +{ + enum { value = + has_value_type<T>::value + & has_reference<T>::value + & has_pointer<T>::value + & has_difference_type<T>::value + & has_iterator_category<T>::value + }; +}; + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_full_iterator_traits,T,::boost::detail::is_full_iterator_traits_impl<T>::value) + + +# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF +BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category) + +// is_stlport_40_debug_iterator -- +// +// A metafunction returning true iff T has all the requisite nested +// types to satisfy the requirements of an STLPort 4.0 debug iterator +// iterator_traits implementation. +template <class T> +struct is_stlport_40_debug_iterator_impl +{ + enum { value = + has_value_type<T>::value + & has_reference<T>::value + & has_pointer<T>::value + & has_difference_type<T>::value + & has__Iterator_category<T>::value + }; +}; + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_stlport_40_debug_iterator,T,::boost::detail::is_stlport_40_debug_iterator_impl<T>::value) + +template <class T> +struct stlport_40_debug_iterator_traits +{ + typedef typename T::value_type value_type; + typedef typename T::reference reference; + typedef typename T::pointer pointer; + typedef typename T::difference_type difference_type; + typedef typename T::_Iterator_category iterator_category; +}; +# endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF + +template <class T> struct pointer_iterator_traits; + +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template <class T> +struct pointer_iterator_traits<T*> +{ + typedef typename remove_const<T>::type value_type; + typedef T* pointer; + typedef T& reference; + typedef std::random_access_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; +}; +# else + +// In case of no template partial specialization, and if T is a +// pointer, iterator_traits<T>::value_type can still be computed. For +// some basic types, remove_pointer is manually defined in +// type_traits/broken_compiler_spec.hpp. For others, do it yourself. + +template<class P> class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee; + +template<class P> +struct pointer_value_type + : mpl::if_< + is_same<P, typename remove_pointer<P>::type> + , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P> + , typename remove_const< + typename remove_pointer<P>::type + >::type + > +{ +}; + + +template<class P> +struct pointer_reference + : mpl::if_< + is_same<P, typename remove_pointer<P>::type> + , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P> + , typename remove_pointer<P>::type& + > +{ +}; + +template <class T> +struct pointer_iterator_traits +{ + typedef T pointer; + typedef std::random_access_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; + + typedef typename pointer_value_type<T>::type value_type; + typedef typename pointer_reference<T>::type reference; +}; + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// We'll sort iterator types into one of these classifications, from which we +// can determine the difference_type, pointer, reference, and value_type +template <class Iterator> +struct standard_iterator_traits +{ + typedef typename Iterator::difference_type difference_type; + typedef typename Iterator::value_type value_type; + typedef typename Iterator::pointer pointer; + typedef typename Iterator::reference reference; + typedef typename Iterator::iterator_category iterator_category; +}; + +template <class Iterator> +struct msvc_stdlib_mutable_traits + : std::iterator_traits<Iterator> +{ + typedef typename std::iterator_traits<Iterator>::distance_type difference_type; + typedef typename std::iterator_traits<Iterator>::value_type* pointer; + typedef typename std::iterator_traits<Iterator>::value_type& reference; +}; + +template <class Iterator> +struct msvc_stdlib_const_traits + : std::iterator_traits<Iterator> +{ + typedef typename std::iterator_traits<Iterator>::distance_type difference_type; + typedef const typename std::iterator_traits<Iterator>::value_type* pointer; + typedef const typename std::iterator_traits<Iterator>::value_type& reference; +}; + +# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION +template <class Iterator> +struct is_bad_output_iterator + : is_base_and_derived< + std::iterator<std::output_iterator_tag,void,void,void,void> + , Iterator> +{ +}; + +struct bad_output_iterator_traits +{ + typedef void value_type; + typedef void difference_type; + typedef std::output_iterator_tag iterator_category; + typedef void pointer; + typedef void reference; +}; +# endif + +// If we're looking at an MSVC6 (old Dinkumware) ``standard'' +// iterator, this will generate an appropriate traits class. +template <class Iterator> +struct msvc_stdlib_iterator_traits + : mpl::if_< + is_mutable_iterator<Iterator> + , msvc_stdlib_mutable_traits<Iterator> + , msvc_stdlib_const_traits<Iterator> + >::type +{}; + +template <class Iterator> +struct non_pointer_iterator_traits + : mpl::if_< + // if the iterator contains all the right nested types... + is_full_iterator_traits<Iterator> + // Use a standard iterator_traits implementation + , standard_iterator_traits<Iterator> +# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF + // Check for STLPort 4.0 broken _Iterator_category type + , mpl::if_< + is_stlport_40_debug_iterator<Iterator> + , stlport_40_debug_iterator_traits<Iterator> +# endif + // Otherwise, assume it's a Dinkum iterator + , msvc_stdlib_iterator_traits<Iterator> +# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF + >::type +# endif + >::type +{ +}; + +template <class Iterator> +struct iterator_traits_aux + : mpl::if_< + is_pointer<Iterator> + , pointer_iterator_traits<Iterator> + , non_pointer_iterator_traits<Iterator> + >::type +{ +}; + +template <class Iterator> +struct iterator_traits +{ + // Explicit forwarding from base class needed to keep MSVC6 happy + // under some circumstances. + private: +# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION + typedef + typename mpl::if_< + is_bad_output_iterator<Iterator> + , bad_output_iterator_traits + , iterator_traits_aux<Iterator> + >::type base; +# else + typedef iterator_traits_aux<Iterator> base; +# endif + public: + typedef typename base::value_type value_type; + typedef typename base::pointer pointer; + typedef typename base::reference reference; + typedef typename base::difference_type difference_type; + typedef typename base::iterator_category iterator_category; +}; + +// This specialization cuts off ETI (Early Template Instantiation) for MSVC. +template <> struct iterator_traits<int> +{ + typedef int value_type; + typedef int pointer; + typedef int reference; + typedef int difference_type; + typedef int iterator_category; +}; + +}} // namespace boost::detail + +# endif // workarounds + +namespace boost { namespace detail { + +namespace iterator_traits_ +{ + template <class Iterator, class Difference> + struct distance_select + { + static Difference execute(Iterator i1, const Iterator i2, ...) + { + Difference result = 0; + while (i1 != i2) + { + ++i1; + ++result; + } + return result; + } + + static Difference execute(Iterator i1, const Iterator i2, std::random_access_iterator_tag*) + { + return i2 - i1; + } + }; +} // namespace boost::detail::iterator_traits_ + +template <class Iterator> +inline typename iterator_traits<Iterator>::difference_type +distance(Iterator first, Iterator last) +{ + typedef typename iterator_traits<Iterator>::difference_type diff_t; + typedef typename ::boost::detail::iterator_traits<Iterator>::iterator_category iterator_category; + + return iterator_traits_::distance_select<Iterator,diff_t>::execute( + first, last, (iterator_category*)0); +} + +}} + +# endif + + +# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF +# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION + +#endif // ITERATOR_DWA122600_HPP_ diff --git a/boost/detail/lcast_precision.hpp b/boost/detail/lcast_precision.hpp new file mode 100644 index 0000000000..93abce18ce --- /dev/null +++ b/boost/detail/lcast_precision.hpp @@ -0,0 +1,184 @@ +// Copyright Alexander Nasonov & Paul A. Bristow 2006. + +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt +// or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED +#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED + +#include <climits> +#include <ios> +#include <limits> + +#include <boost/config.hpp> +#include <boost/integer_traits.hpp> + +#ifndef BOOST_NO_IS_ABSTRACT +// Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_abstract.hpp> +#endif + +#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \ + (defined(BOOST_MSVC) && (BOOST_MSVC<1310)) + +#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION +#endif + +#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION +#include <boost/assert.hpp> +#else +#include <boost/static_assert.hpp> +#endif + +namespace boost { namespace detail { + +class lcast_abstract_stub {}; + +#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION +// Calculate an argument to pass to std::ios_base::precision from +// lexical_cast. See alternative implementation for broken standard +// libraries in lcast_get_precision below. Keep them in sync, please. +template<class T> +struct lcast_precision +{ +#ifdef BOOST_NO_IS_ABSTRACT + typedef std::numeric_limits<T> limits; // No fix for SF:1358600. +#else + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::is_abstract<T> + , std::numeric_limits<lcast_abstract_stub> + , std::numeric_limits<T> + >::type limits; +#endif + + BOOST_STATIC_CONSTANT(bool, use_default_precision = + !limits::is_specialized || limits::is_exact + ); + + BOOST_STATIC_CONSTANT(bool, is_specialized_bin = + !use_default_precision && + limits::radix == 2 && limits::digits > 0 + ); + + BOOST_STATIC_CONSTANT(bool, is_specialized_dec = + !use_default_precision && + limits::radix == 10 && limits::digits10 > 0 + ); + + BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max = + boost::integer_traits<std::streamsize>::const_max + ); + + BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U); + + BOOST_STATIC_ASSERT(!is_specialized_dec || + precision_dec <= streamsize_max + 0UL + ); + + BOOST_STATIC_CONSTANT(unsigned long, precision_bin = + 2UL + limits::digits * 30103UL / 100000UL + ); + + BOOST_STATIC_ASSERT(!is_specialized_bin || + (limits::digits + 0UL < ULONG_MAX / 30103UL && + precision_bin > limits::digits10 + 0UL && + precision_bin <= streamsize_max + 0UL) + ); + + BOOST_STATIC_CONSTANT(std::streamsize, value = + is_specialized_bin ? precision_bin + : is_specialized_dec ? precision_dec : 6 + ); +}; +#endif + +template<class T> +inline std::streamsize lcast_get_precision(T* = 0) +{ +#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION + return lcast_precision<T>::value; +#else // Follow lcast_precision algorithm at run-time: + +#ifdef BOOST_NO_IS_ABSTRACT + typedef std::numeric_limits<T> limits; // No fix for SF:1358600. +#else + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::is_abstract<T> + , std::numeric_limits<lcast_abstract_stub> + , std::numeric_limits<T> + >::type limits; +#endif + + bool const use_default_precision = + !limits::is_specialized || limits::is_exact; + + if(!use_default_precision) + { // Includes all built-in floating-point types, float, double ... + // and UDT types for which digits (significand bits) is defined (not zero) + + bool const is_specialized_bin = + limits::radix == 2 && limits::digits > 0; + bool const is_specialized_dec = + limits::radix == 10 && limits::digits10 > 0; + std::streamsize const streamsize_max = + (boost::integer_traits<std::streamsize>::max)(); + + if(is_specialized_bin) + { // Floating-point types with + // limits::digits defined by the specialization. + + unsigned long const digits = limits::digits; + unsigned long const precision = 2UL + digits * 30103UL / 100000UL; + // unsigned long is selected because it is at least 32-bits + // and thus ULONG_MAX / 30103UL is big enough for all types. + BOOST_ASSERT( + digits < ULONG_MAX / 30103UL && + precision > limits::digits10 + 0UL && + precision <= streamsize_max + 0UL + ); + return precision; + } + else if(is_specialized_dec) + { // Decimal Floating-point type, most likely a User Defined Type + // rather than a real floating-point hardware type. + unsigned int const precision = limits::digits10 + 1U; + BOOST_ASSERT(precision <= streamsize_max + 0UL); + return precision; + } + } + + // Integral type (for which precision has no effect) + // or type T for which limits is NOT specialized, + // so assume stream precision remains the default 6 decimal digits. + // Warning: if your User-defined Floating-point type T is NOT specialized, + // then you may lose accuracy by only using 6 decimal digits. + // To avoid this, you need to specialize T with either + // radix == 2 and digits == the number of significand bits, + // OR + // radix = 10 and digits10 == the number of decimal digits. + + return 6; +#endif +} + +template<class T> +inline void lcast_set_precision(std::ios_base& stream, T*) +{ + stream.precision(lcast_get_precision<T>()); +} + +template<class Source, class Target> +inline void lcast_set_precision(std::ios_base& stream, Source*, Target*) +{ + std::streamsize const s = lcast_get_precision(static_cast<Source*>(0)); + std::streamsize const t = lcast_get_precision(static_cast<Target*>(0)); + stream.precision(s > t ? s : t); +} + +}} + +#endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED + diff --git a/boost/detail/lightweight_main.hpp b/boost/detail/lightweight_main.hpp new file mode 100644 index 0000000000..1705309780 --- /dev/null +++ b/boost/detail/lightweight_main.hpp @@ -0,0 +1,36 @@ +// boost/detail/lightweight_main.hpp -------------------------------------------------// + +// Copyright Beman Dawes 2010 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#include <iostream> +#include <exception> + +//--------------------------------------------------------------------------------------// +// // +// exception reporting main() that calls cpp_main() // +// // +//--------------------------------------------------------------------------------------// + +int cpp_main(int argc, char* argv[]); + +int main(int argc, char* argv[]) +{ + try + { + return cpp_main(argc, argv); + } + + catch (const std::exception& ex) + { + std::cout + << "\nERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR\n" + << "\n****************************** std::exception *****************************\n" + << ex.what() + << "\n***************************************************************************\n" + << std::endl; + } + return 1; +} diff --git a/boost/detail/lightweight_mutex.hpp b/boost/detail/lightweight_mutex.hpp new file mode 100644 index 0000000000..b7a7f6dd4e --- /dev/null +++ b/boost/detail/lightweight_mutex.hpp @@ -0,0 +1,22 @@ +#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED +#define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/lightweight_mutex.hpp - lightweight mutex +// +// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// + +#include <boost/smart_ptr/detail/lightweight_mutex.hpp> + +#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED diff --git a/boost/detail/lightweight_test.hpp b/boost/detail/lightweight_test.hpp new file mode 100644 index 0000000000..dbd99b97e9 --- /dev/null +++ b/boost/detail/lightweight_test.hpp @@ -0,0 +1,143 @@ +#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED +#define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/lightweight_test.hpp - lightweight test library +// +// Copyright (c) 2002, 2009 Peter Dimov +// Copyright (2) Beman Dawes 2010, 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// BOOST_TEST(expression) +// BOOST_ERROR(message) +// BOOST_TEST_EQ(expr1, expr2) +// +// int boost::report_errors() +// + +#include <iostream> +#include <boost/current_function.hpp> +#include <boost/assert.hpp> + +// IDE's like Visual Studio perform better if output goes to std::cout or +// some other stream, so allow user to configure output stream: +#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM +# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr +#endif + +namespace boost +{ + +namespace detail +{ + +struct report_errors_reminder +{ + bool called_report_errors_function; + report_errors_reminder() : called_report_errors_function(false) {} + ~report_errors_reminder() + { + BOOST_ASSERT(called_report_errors_function); // verify report_errors() was called + } +}; + +inline report_errors_reminder& report_errors_remind() +{ + static report_errors_reminder r; + return r; +} + +inline int & test_errors() +{ + static int x = 0; + report_errors_remind(); + return x; +} + +inline void test_failed_impl(char const * expr, char const * file, int line, char const * function) +{ + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): test '" << expr << "' failed in function '" + << function << "'" << std::endl; + ++test_errors(); +} + +inline void error_impl(char const * msg, char const * file, int line, char const * function) +{ + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): " << msg << " in function '" + << function << "'" << std::endl; + ++test_errors(); +} + +template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2, + char const * file, int line, char const * function, T const & t, U const & u ) +{ + if( t == u ) + { + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): test '" << expr1 << " == " << expr2 + << "' failed in function '" << function << "': " + << "'" << t << "' != '" << u << "'" << std::endl; + ++test_errors(); + } +} + +template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2, + char const * file, int line, char const * function, T const & t, U const & u ) +{ + if( t != u ) + { + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): test '" << expr1 << " != " << expr2 + << "' failed in function '" << function << "': " + << "'" << t << "' == '" << u << "'" << std::endl; + ++test_errors(); + } +} + +} // namespace detail + +inline int report_errors() +{ + detail::report_errors_remind().called_report_errors_function = true; + + int errors = detail::test_errors(); + + if( errors == 0 ) + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << "No errors detected." << std::endl; + return 0; + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl; + return 1; + } +} + +} // namespace boost + +#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)) +#define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) +#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) ) +#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) ) + +#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED diff --git a/boost/detail/lightweight_thread.hpp b/boost/detail/lightweight_thread.hpp new file mode 100644 index 0000000000..6fe70a613d --- /dev/null +++ b/boost/detail/lightweight_thread.hpp @@ -0,0 +1,135 @@ +#ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED +#define BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// boost/detail/lightweight_thread.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// Copyright (c) 2008 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt + +#include <boost/config.hpp> +#include <memory> +#include <cerrno> + +// pthread_create, pthread_join + +#if defined( BOOST_HAS_PTHREADS ) + +#include <pthread.h> + +#else + +#include <windows.h> +#include <process.h> + +typedef HANDLE pthread_t; + +int pthread_create( pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg ) +{ + HANDLE h = (HANDLE)_beginthreadex( 0, 0, start_routine, arg, 0, 0 ); + + if( h != 0 ) + { + *thread = h; + return 0; + } + else + { + return EAGAIN; + } +} + +int pthread_join( pthread_t thread, void ** /*value_ptr*/ ) +{ + ::WaitForSingleObject( thread, INFINITE ); + ::CloseHandle( thread ); + return 0; +} + +#endif + +// template<class F> int lw_thread_create( pthread_t & pt, F f ); + +namespace boost +{ + +namespace detail +{ + +class lw_abstract_thread +{ +public: + + virtual ~lw_abstract_thread() {} + virtual void run() = 0; +}; + +#if defined( BOOST_HAS_PTHREADS ) + +extern "C" void * lw_thread_routine( void * pv ) +{ + std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) ); + + pt->run(); + + return 0; +} + +#else + +unsigned __stdcall lw_thread_routine( void * pv ) +{ + std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) ); + + pt->run(); + + return 0; +} + +#endif + +template<class F> class lw_thread_impl: public lw_abstract_thread +{ +public: + + explicit lw_thread_impl( F f ): f_( f ) + { + } + + void run() + { + f_(); + } + +private: + + F f_; +}; + +template<class F> int lw_thread_create( pthread_t & pt, F f ) +{ + std::auto_ptr<lw_abstract_thread> p( new lw_thread_impl<F>( f ) ); + + int r = pthread_create( &pt, 0, lw_thread_routine, p.get() ); + + if( r == 0 ) + { + p.release(); + } + + return r; +} + +} // namespace detail +} // namespace boost + +#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED diff --git a/boost/detail/limits.hpp b/boost/detail/limits.hpp new file mode 100644 index 0000000000..6f018dfaca --- /dev/null +++ b/boost/detail/limits.hpp @@ -0,0 +1,449 @@ +// Copyright 2001 John Maddock +// Distributed under the Boost Software License, Version 1.0. (See accompany- +// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +/* + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/* NOTE: This is not portable code. Parts of numeric_limits<> are + * inherently machine-dependent, and this file is written for the MIPS + * architecture and the SGI MIPSpro C++ compiler. Parts of it (in + * particular, some of the characteristics of floating-point types) + * are almost certainly incorrect for any other platform. + */ + +/* The above comment is almost certainly out of date. This file works + * on systems other than SGI MIPSpro C++ now. + */ + +/* + * Revision history: + * 21 Sep 2001: + * Only include <cwchar> if BOOST_NO_CWCHAR is defined. (Darin Adler) + * 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: + * Added sparc (big endian) processor support (John Maddock). + * Initial sub: + * Modified by Jens Maurer for gcc 2.95 on x86. + */ + +#ifndef BOOST_SGI_CPP_LIMITS +#define BOOST_SGI_CPP_LIMITS + +#include <climits> +#include <cfloat> +#include <boost/config.hpp> +#include <boost/detail/endian.hpp> + +#ifndef BOOST_NO_CWCHAR +#include <cwchar> // for WCHAR_MIN and WCHAR_MAX +#endif + +namespace std { + +enum float_round_style { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 +}; + +enum float_denorm_style { + denorm_indeterminate = -1, + denorm_absent = 0, + denorm_present = 1 +}; + +// The C++ standard (section 18.2.1) requires that some of the members of +// numeric_limits be static const data members that are given constant- +// initializers within the class declaration. On compilers where the +// BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro is defined, it is impossible to write +// a standard-conforming numeric_limits class. +// +// There are two possible workarounds: either initialize the data +// members outside the class, or change them from data members to +// enums. Neither workaround is satisfactory: the former makes it +// impossible to use the data members in constant-expressions, and the +// latter means they have the wrong type and that it is impossible to +// take their addresses. We choose the former workaround. + +#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \ + enum { __mem_name = __mem_value } +#else /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */ +# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \ + static const __mem_type __mem_name = __mem_value +#endif /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */ + +// Base class for all specializations of numeric_limits. +template <class __number> +class _Numeric_limits_base { +public: + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false); + + static __number min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); } + static __number max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); } + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, 0); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, 0); + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, false); + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 0); + + static __number epsilon() throw() { return __number(); } + static __number round_error() throw() { return __number(); } + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, 0); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, 0); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0); + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style, + has_denorm, + denorm_absent); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false); + + static __number infinity() throw() { return __number(); } + static __number quiet_NaN() throw() { return __number(); } + static __number signaling_NaN() throw() { return __number(); } + static __number denorm_min() throw() { return __number(); } + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false); + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false); + BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, + round_style, + round_toward_zero); +}; + +// Base class for integers. + +template <class _Int, + _Int __imin, + _Int __imax, + int __idigits = -1> +class _Integer_limits : public _Numeric_limits_base<_Int> +{ +public: + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true); + + static _Int min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imin; } + static _Int max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imax; } + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, + digits, + (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT) + - (__imin == 0 ? 0 : 1) + : __idigits); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000); + // log 2 = 0.301029995664... + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2); + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true); +}; + +#if defined(BOOST_BIG_ENDIAN) + + template<class Number, unsigned int Word> + struct float_helper{ + static Number get_word() throw() { + // sizeof(long double) == 16 + const unsigned int _S_word[4] = { Word, 0, 0, 0 }; + return *reinterpret_cast<const Number*>(&_S_word); + } +}; + +#else + + template<class Number, unsigned int Word> + struct float_helper{ + static Number get_word() throw() { + // sizeof(long double) == 12, but only 10 bytes significant + const unsigned int _S_word[4] = { 0, 0, 0, Word }; + return *reinterpret_cast<const Number*>( + reinterpret_cast<const char *>(&_S_word)+16- + (sizeof(Number) == 12 ? 10 : sizeof(Number))); + } +}; + +#endif + +// Base class for floating-point numbers. +template <class __number, + int __Digits, int __Digits10, + int __MinExp, int __MaxExp, + int __MinExp10, int __MaxExp10, + unsigned int __InfinityWord, + unsigned int __QNaNWord, unsigned int __SNaNWord, + bool __IsIEC559, + float_round_style __RoundStyle> +class _Floating_limits : public _Numeric_limits_base<__number> +{ +public: + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true); + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, __Digits); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10); + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true); + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2); + + BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, __MinExp); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, __MaxExp); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10); + BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10); + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style, + has_denorm, + denorm_indeterminate); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false); + + + static __number infinity() throw() { + return float_helper<__number, __InfinityWord>::get_word(); + } + static __number quiet_NaN() throw() { + return float_helper<__number,__QNaNWord>::get_word(); + } + static __number signaling_NaN() throw() { + return float_helper<__number,__SNaNWord>::get_word(); + } + + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, __IsIEC559); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false /* was: true */ ); + BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false); + + BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle); +}; + +// Class numeric_limits + +// The unspecialized class. + +template<class T> +class numeric_limits : public _Numeric_limits_base<T> {}; + +// Specializations for all built-in integral types. + +template<> +class numeric_limits<bool> + : public _Integer_limits<bool, false, true, 0> +{}; + +template<> +class numeric_limits<char> + : public _Integer_limits<char, CHAR_MIN, CHAR_MAX> +{}; + +template<> +class numeric_limits<signed char> + : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX> +{}; + +template<> +class numeric_limits<unsigned char> + : public _Integer_limits<unsigned char, 0, UCHAR_MAX> +{}; + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template<> +class numeric_limits<wchar_t> +#if !defined(WCHAR_MAX) || !defined(WCHAR_MIN) +#if defined(_WIN32) || defined(__CYGWIN__) + : public _Integer_limits<wchar_t, 0, USHRT_MAX> +#elif defined(__hppa) +// wchar_t has "unsigned int" as the underlying type + : public _Integer_limits<wchar_t, 0, UINT_MAX> +#else +// assume that wchar_t has "int" as the underlying type + : public _Integer_limits<wchar_t, INT_MIN, INT_MAX> +#endif +#else +// we have WCHAR_MIN and WCHAR_MAX defined, so use it + : public _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX> +#endif +{}; +#endif + +template<> +class numeric_limits<short> + : public _Integer_limits<short, SHRT_MIN, SHRT_MAX> +{}; + +template<> +class numeric_limits<unsigned short> + : public _Integer_limits<unsigned short, 0, USHRT_MAX> +{}; + +template<> +class numeric_limits<int> + : public _Integer_limits<int, INT_MIN, INT_MAX> +{}; + +template<> +class numeric_limits<unsigned int> + : public _Integer_limits<unsigned int, 0, UINT_MAX> +{}; + +template<> +class numeric_limits<long> + : public _Integer_limits<long, LONG_MIN, LONG_MAX> +{}; + +template<> +class numeric_limits<unsigned long> + : public _Integer_limits<unsigned long, 0, ULONG_MAX> +{}; + +#ifdef __GNUC__ + +// Some compilers have long long, but don't define the +// LONGLONG_MIN and LONGLONG_MAX macros in limits.h. This +// assumes that long long is 64 bits. +#if !defined(LONGLONG_MAX) && !defined(ULONGLONG_MAX) + +# define ULONGLONG_MAX 0xffffffffffffffffLLU +# define LONGLONG_MAX 0x7fffffffffffffffLL + +#endif + +#if !defined(LONGLONG_MIN) +# define LONGLONG_MIN (-LONGLONG_MAX - 1) +#endif + + +#if !defined(ULONGLONG_MIN) +# define ULONGLONG_MIN 0 +#endif + +#endif /* __GNUC__ */ + +// Specializations for all built-in floating-point type. + +template<> class numeric_limits<float> + : public _Floating_limits<float, + FLT_MANT_DIG, // Binary digits of precision + FLT_DIG, // Decimal digits of precision + FLT_MIN_EXP, // Minimum exponent + FLT_MAX_EXP, // Maximum exponent + FLT_MIN_10_EXP, // Minimum base 10 exponent + FLT_MAX_10_EXP, // Maximum base 10 exponent +#if defined(BOOST_BIG_ENDIAN) + 0x7f80 << (sizeof(int)*CHAR_BIT-16), // Last word of +infinity + 0x7f81 << (sizeof(int)*CHAR_BIT-16), // Last word of quiet NaN + 0x7fc1 << (sizeof(int)*CHAR_BIT-16), // Last word of signaling NaN +#else + 0x7f800000u, // Last word of +infinity + 0x7f810000u, // Last word of quiet NaN + 0x7fc10000u, // Last word of signaling NaN +#endif + true, // conforms to iec559 + round_to_nearest> +{ +public: + static float min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MIN; } + static float denorm_min() throw() { return FLT_MIN; } + static float max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MAX; } + static float epsilon() throw() { return FLT_EPSILON; } + static float round_error() throw() { return 0.5f; } // Units: ulps. +}; + +template<> class numeric_limits<double> + : public _Floating_limits<double, + DBL_MANT_DIG, // Binary digits of precision + DBL_DIG, // Decimal digits of precision + DBL_MIN_EXP, // Minimum exponent + DBL_MAX_EXP, // Maximum exponent + DBL_MIN_10_EXP, // Minimum base 10 exponent + DBL_MAX_10_EXP, // Maximum base 10 exponent +#if defined(BOOST_BIG_ENDIAN) + 0x7ff0 << (sizeof(int)*CHAR_BIT-16), // Last word of +infinity + 0x7ff1 << (sizeof(int)*CHAR_BIT-16), // Last word of quiet NaN + 0x7ff9 << (sizeof(int)*CHAR_BIT-16), // Last word of signaling NaN +#else + 0x7ff00000u, // Last word of +infinity + 0x7ff10000u, // Last word of quiet NaN + 0x7ff90000u, // Last word of signaling NaN +#endif + true, // conforms to iec559 + round_to_nearest> +{ +public: + static double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MIN; } + static double denorm_min() throw() { return DBL_MIN; } + static double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MAX; } + static double epsilon() throw() { return DBL_EPSILON; } + static double round_error() throw() { return 0.5; } // Units: ulps. +}; + +template<> class numeric_limits<long double> + : public _Floating_limits<long double, + LDBL_MANT_DIG, // Binary digits of precision + LDBL_DIG, // Decimal digits of precision + LDBL_MIN_EXP, // Minimum exponent + LDBL_MAX_EXP, // Maximum exponent + LDBL_MIN_10_EXP,// Minimum base 10 exponent + LDBL_MAX_10_EXP,// Maximum base 10 exponent +#if defined(BOOST_BIG_ENDIAN) + 0x7ff0 << (sizeof(int)*CHAR_BIT-16), // Last word of +infinity + 0x7ff1 << (sizeof(int)*CHAR_BIT-16), // Last word of quiet NaN + 0x7ff9 << (sizeof(int)*CHAR_BIT-16), // Last word of signaling NaN +#else + 0x7fff8000u, // Last word of +infinity + 0x7fffc000u, // Last word of quiet NaN + 0x7fff9000u, // Last word of signaling NaN +#endif + false, // Doesn't conform to iec559 + round_to_nearest> +{ +public: + static long double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MIN; } + static long double denorm_min() throw() { return LDBL_MIN; } + static long double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MAX; } + static long double epsilon() throw() { return LDBL_EPSILON; } + static long double round_error() throw() { return 4; } // Units: ulps. +}; + +} // namespace std + +#endif /* BOOST_SGI_CPP_LIMITS */ + +// Local Variables: +// mode:C++ +// End: + + + diff --git a/boost/detail/named_template_params.hpp b/boost/detail/named_template_params.hpp new file mode 100644 index 0000000000..e7cb079433 --- /dev/null +++ b/boost/detail/named_template_params.hpp @@ -0,0 +1,177 @@ +// (C) Copyright Jeremy Siek 2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Revision History: + +// 04 Oct 2001 David Abrahams +// Changed name of "bind" to "select" to avoid problems with MSVC. + +#ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP +#define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP + +#include <boost/type_traits/conversion_traits.hpp> +#include <boost/type_traits/composite_traits.hpp> // for is_reference +#if defined(__BORLANDC__) +#include <boost/type_traits/ice.hpp> +#endif + +namespace boost { + namespace detail { + + struct default_argument { }; + + struct dummy_default_gen { + template <class Base, class Traits> + struct select { + typedef default_argument type; + }; + }; + + // This class template is a workaround for MSVC. + template <class Gen> struct default_generator { + typedef detail::dummy_default_gen type; + }; + + template <class T> struct is_default { + enum { value = false }; + typedef type_traits::no_type type; + }; + template <> struct is_default<default_argument> { + enum { value = true }; + typedef type_traits::yes_type type; + }; + + struct choose_default { + template <class Arg, class DefaultGen, class Base, class Traits> + struct select { + typedef typename default_generator<DefaultGen>::type Gen; + typedef typename Gen::template select<Base,Traits>::type type; + }; + }; + struct choose_arg { + template <class Arg, class DefaultGen, class Base, class Traits> + struct select { + typedef Arg type; + }; + }; + +#if defined(__BORLANDC__) + template <class UseDefault> + struct choose_arg_or_default { typedef choose_arg type; }; + template <> + struct choose_arg_or_default<type_traits::yes_type> { + typedef choose_default type; + }; +#else + template <bool UseDefault> + struct choose_arg_or_default { typedef choose_arg type; }; + template <> + struct choose_arg_or_default<true> { + typedef choose_default type; + }; +#endif + + template <class Arg, class DefaultGen, class Base, class Traits> + class resolve_default { +#if defined(__BORLANDC__) + typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector; +#else + // This usually works for Borland, but I'm seeing weird errors in + // iterator_adaptor_test.cpp when using this method. + enum { is_def = is_default<Arg>::value }; + typedef typename choose_arg_or_default<is_def>::type Selector; +#endif + public: + typedef typename Selector + ::template select<Arg, DefaultGen, Base, Traits>::type type; + }; + + // To differentiate an unnamed parameter from a traits generator + // we use is_convertible<X, iter_traits_gen_base>. + struct named_template_param_base { }; + + template <class X> + struct is_named_param_list { + enum { value = is_convertible<X, named_template_param_base>::value }; + }; + + struct choose_named_params { + template <class Prev> struct select { typedef Prev type; }; + }; + struct choose_default_arg { + template <class Prev> struct select { + typedef detail::default_argument type; + }; + }; + + template <bool Named> struct choose_default_dispatch_; + template <> struct choose_default_dispatch_<true> { + typedef choose_named_params type; + }; + template <> struct choose_default_dispatch_<false> { + typedef choose_default_arg type; + }; + // The use of inheritance here is a Solaris Forte 6 workaround. + template <bool Named> struct choose_default_dispatch + : public choose_default_dispatch_<Named> { }; + + template <class PreviousArg> + struct choose_default_argument { + enum { is_named = is_named_param_list<PreviousArg>::value }; + typedef typename choose_default_dispatch<is_named>::type Selector; + typedef typename Selector::template select<PreviousArg>::type type; + }; + + // This macro assumes that there is a class named default_##TYPE + // defined before the application of the macro. This class should + // have a single member class template named "select" with two + // template parameters: the type of the class being created (e.g., + // the iterator_adaptor type when creating iterator adaptors) and + // a traits class. The select class should have a single typedef + // named "type" that produces the default for TYPE. See + // boost/iterator_adaptors.hpp for an example usage. Also, + // applications of this macro must be placed in namespace + // boost::detail. + +#define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \ + struct get_##TYPE##_from_named { \ + template <class Base, class NamedParams, class Traits> \ + struct select { \ + typedef typename NamedParams::traits NamedTraits; \ + typedef typename NamedTraits::TYPE TYPE; \ + typedef typename resolve_default<TYPE, \ + default_##TYPE, Base, NamedTraits>::type type; \ + }; \ + }; \ + struct pass_thru_##TYPE { \ + template <class Base, class Arg, class Traits> struct select { \ + typedef typename resolve_default<Arg, \ + default_##TYPE, Base, Traits>::type type; \ + };\ + }; \ + template <int NamedParam> \ + struct get_##TYPE##_dispatch { }; \ + template <> struct get_##TYPE##_dispatch<1> { \ + typedef get_##TYPE##_from_named type; \ + }; \ + template <> struct get_##TYPE##_dispatch<0> { \ + typedef pass_thru_##TYPE type; \ + }; \ + template <class Base, class X, class Traits> \ + class get_##TYPE { \ + enum { is_named = is_named_param_list<X>::value }; \ + typedef typename get_##TYPE##_dispatch<is_named>::type Selector; \ + public: \ + typedef typename Selector::template select<Base, X, Traits>::type type; \ + }; \ + template <> struct default_generator<default_##TYPE> { \ + typedef default_##TYPE type; \ + } + + + } // namespace detail +} // namespace boost + +#endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP diff --git a/boost/detail/no_exceptions_support.hpp b/boost/detail/no_exceptions_support.hpp new file mode 100644 index 0000000000..d94e35834f --- /dev/null +++ b/boost/detail/no_exceptions_support.hpp @@ -0,0 +1,87 @@ +#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ +#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ + +#if (defined _MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +//---------------------------------------------------------------------- +// (C) Copyright 2004 Pavel Vozenilek. +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt +// or copy at http://www.boost.org/LICENSE_1_0.txt) +// +// +// This file contains helper macros used when exception support may be +// disabled (as indicated by macro BOOST_NO_EXCEPTIONS). +// +// Before picking up these macros you may consider using RAII techniques +// to deal with exceptions - their syntax can be always the same with +// or without exception support enabled. +// + +/* Example of use: + +void foo() { + BOOST_TRY { + ... + } BOOST_CATCH(const std::bad_alloc&) { + ... + BOOST_RETHROW + } BOOST_CATCH(const std::exception& e) { + ... + } + BOOST_CATCH_END +} + +With exception support enabled it will expand into: + +void foo() { + { try { + ... + } catch (const std::bad_alloc&) { + ... + throw; + } catch (const std::exception& e) { + ... + } + } +} + +With exception support disabled it will expand into: + +void foo() { + { if(true) { + ... + } else if (false) { + ... + } else if (false) { + ... + } + } +} +*/ +//---------------------------------------------------------------------- + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#if !(defined BOOST_NO_EXCEPTIONS) +# define BOOST_TRY { try +# define BOOST_CATCH(x) catch(x) +# define BOOST_RETHROW throw; +# define BOOST_CATCH_END } +#else +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# define BOOST_TRY { if ("") +# define BOOST_CATCH(x) else if (!"") +# else +# define BOOST_TRY { if (true) +# define BOOST_CATCH(x) else if (false) +# endif +# define BOOST_RETHROW +# define BOOST_CATCH_END } +#endif + + +#endif diff --git a/boost/detail/none_t.hpp b/boost/detail/none_t.hpp new file mode 100644 index 0000000000..40805ec0ff --- /dev/null +++ b/boost/detail/none_t.hpp @@ -0,0 +1,28 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_DETAIL_NONE_T_17SEP2003_HPP +#define BOOST_DETAIL_NONE_T_17SEP2003_HPP + +namespace boost { + +namespace detail { + +struct none_helper{}; + +typedef int none_helper::*none_t ; + +} // namespace detail + +} // namespace boost + +#endif + diff --git a/boost/detail/numeric_traits.hpp b/boost/detail/numeric_traits.hpp new file mode 100644 index 0000000000..6325d70cb0 --- /dev/null +++ b/boost/detail/numeric_traits.hpp @@ -0,0 +1,191 @@ +// (C) Copyright David Abrahams 2001, Howard Hinnant 2001. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// Template class numeric_traits<Number> -- +// +// Supplies: +// +// typedef difference_type -- a type used to represent the difference +// between any two values of Number. +// +// Support: +// 1. Not all specializations are supplied +// +// 2. Use of specializations that are not supplied will cause a +// compile-time error +// +// 3. Users are free to specialize numeric_traits for any type. +// +// 4. Right now, specializations are only supplied for integer types. +// +// 5. On implementations which do not supply compile-time constants in +// std::numeric_limits<>, only specializations for built-in integer types +// are supplied. +// +// 6. Handling of numbers whose range of representation is at least as +// great as boost::intmax_t can cause some differences to be +// unrepresentable in difference_type: +// +// Number difference_type +// ------ --------------- +// signed Number +// unsigned intmax_t +// +// template <class Number> typename numeric_traits<Number>::difference_type +// numeric_distance(Number x, Number y) +// computes (y - x), attempting to avoid overflows. +// + +// See http://www.boost.org for most recent version including documentation. + +// Revision History +// 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams) +// 11 Feb 2001 - Rolled back ineffective Borland-specific code +// (David Abrahams) +// 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but +// not seeing any improvement yet (David Abrahams) +// 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp +// (David Abrahams) +// 23 Jan 2001 - Fixed logic of difference_type selection, which was +// completely wack. In the process, added digit_traits<> +// to compute the number of digits in intmax_t even when +// not supplied by numeric_limits<>. (David Abrahams) +// 21 Jan 2001 - Created (David Abrahams) + +#ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901 +# define BOOST_NUMERIC_TRAITS_HPP_DWA20001901 + +# include <boost/config.hpp> +# include <boost/cstdint.hpp> +# include <boost/static_assert.hpp> +# include <boost/type_traits.hpp> +# include <boost/detail/select_type.hpp> +# include <boost/limits.hpp> + +namespace boost { namespace detail { + + // Template class is_signed -- determine whether a numeric type is signed + // Requires that T is constructable from the literals -1 and 0. Compile-time + // error results if that requirement is not met (and thus signedness is not + // likely to have meaning for that type). + template <class Number> + struct is_signed + { +#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0))); +#else + BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<Number>::is_signed); +#endif + }; + +# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + // digit_traits - compute the number of digits in a built-in integer + // type. Needed for implementations on which numeric_limits is not specialized + // for intmax_t (e.g. VC6). + template <bool is_specialized> struct digit_traits_select; + + // numeric_limits is specialized; just select that version of digits + template <> struct digit_traits_select<true> + { + template <class T> struct traits + { + BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits); + }; + }; + + // numeric_limits is not specialized; compute digits from sizeof(T) + template <> struct digit_traits_select<false> + { + template <class T> struct traits + { + BOOST_STATIC_CONSTANT(int, digits = ( + sizeof(T) * std::numeric_limits<unsigned char>::digits + - (is_signed<T>::value ? 1 : 0)) + ); + }; + }; + + // here's the "usable" template + template <class T> struct digit_traits + { + typedef digit_traits_select< + ::std::numeric_limits<T>::is_specialized> selector; + typedef typename selector::template traits<T> traits; + BOOST_STATIC_CONSTANT(int, digits = traits::digits); + }; +#endif + + // Template class integer_traits<Integer> -- traits of various integer types + // This should probably be rolled into boost::integer_traits one day, but I + // need it to work without <limits> + template <class Integer> + struct integer_traits + { +# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + private: + typedef Integer integer_type; + typedef std::numeric_limits<integer_type> x; +# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + // for some reason, MSVC asserts when it shouldn't unless we make these + // local definitions + BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer); + BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized); + + BOOST_STATIC_ASSERT(is_integer); + BOOST_STATIC_ASSERT(is_specialized); +# endif + public: + typedef typename + if_true<(int(x::is_signed) + && (!int(x::is_bounded) + // digits is the number of no-sign bits + || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits)))>::template then< + Integer, + + typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then< + signed int, + + typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then< + signed long, + + // else + intmax_t + >::type>::type>::type difference_type; +#else + BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value); + + typedef typename + if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then< + + typename if_true<(is_signed<Integer>::value)>::template then< + Integer, + intmax_t + >::type, + + typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then< + std::ptrdiff_t, + intmax_t + >::type + >::type difference_type; +# endif + }; + + // Right now, only supports integers, but should be expanded. + template <class Number> + struct numeric_traits + { + typedef typename integer_traits<Number>::difference_type difference_type; + }; + + template <class Number> + typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y) + { + typedef typename numeric_traits<Number>::difference_type difference_type; + return difference_type(y) - difference_type(x); + } +}} + +#endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901 diff --git a/boost/detail/ob_call_traits.hpp b/boost/detail/ob_call_traits.hpp new file mode 100644 index 0000000000..eb4df7a30f --- /dev/null +++ b/boost/detail/ob_call_traits.hpp @@ -0,0 +1,168 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. +// +// Crippled version for crippled compilers: +// see libs/utility/call_traits.htm +// + +/* Release notes: + 01st October 2000: + Fixed call_traits on VC6, using "poor man's partial specialisation", + using ideas taken from "Generative programming" by Krzysztof Czarnecki + & Ulrich Eisenecker. +*/ + +#ifndef BOOST_OB_CALL_TRAITS_HPP +#define BOOST_OB_CALL_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +#include <boost/config.hpp> +#endif + +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +#include <boost/type_traits/arithmetic_traits.hpp> +#endif +#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP +#include <boost/type_traits/composite_traits.hpp> +#endif + +namespace boost{ + +#ifdef BOOST_MSVC6_MEMBER_TEMPLATES +// +// use member templates to emulate +// partial specialisation: +// +namespace detail{ + +template <class T> +struct standard_call_traits +{ + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& param_type; +}; +template <class T> +struct simple_call_traits +{ + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T param_type; +}; +template <class T> +struct reference_call_traits +{ + typedef T value_type; + typedef T reference; + typedef T const_reference; + typedef T param_type; +}; + +template <bool pointer, bool arithmetic, bool reference> +struct call_traits_chooser +{ + template <class T> + struct rebind + { + typedef standard_call_traits<T> type; + }; +}; + +template <> +struct call_traits_chooser<true, false, false> +{ + template <class T> + struct rebind + { + typedef simple_call_traits<T> type; + }; +}; + +template <> +struct call_traits_chooser<false, false, true> +{ + template <class T> + struct rebind + { + typedef reference_call_traits<T> type; + }; +}; + +template <bool size_is_small> +struct call_traits_sizeof_chooser2 +{ + template <class T> + struct small_rebind + { + typedef simple_call_traits<T> small_type; + }; +}; + +template<> +struct call_traits_sizeof_chooser2<false> +{ + template <class T> + struct small_rebind + { + typedef standard_call_traits<T> small_type; + }; +}; + +template <> +struct call_traits_chooser<false, true, false> +{ + template <class T> + struct rebind + { + enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) }; + typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser; + typedef typename chooser::template small_rebind<T> bound_type; + typedef typename bound_type::small_type type; + }; +}; + +} // namespace detail +template <typename T> +struct call_traits +{ +private: + typedef detail::call_traits_chooser< + ::boost::is_pointer<T>::value, + ::boost::is_arithmetic<T>::value, + ::boost::is_reference<T>::value + > chooser; + typedef typename chooser::template rebind<T> bound_type; + typedef typename bound_type::type call_traits_type; +public: + typedef typename call_traits_type::value_type value_type; + typedef typename call_traits_type::reference reference; + typedef typename call_traits_type::const_reference const_reference; + typedef typename call_traits_type::param_type param_type; +}; + +#else +// +// sorry call_traits is completely non-functional +// blame your broken compiler: +// + +template <typename T> +struct call_traits +{ + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& param_type; +}; + +#endif // member templates + +} + +#endif // BOOST_OB_CALL_TRAITS_HPP diff --git a/boost/detail/ob_compressed_pair.hpp b/boost/detail/ob_compressed_pair.hpp new file mode 100644 index 0000000000..727acab6da --- /dev/null +++ b/boost/detail/ob_compressed_pair.hpp @@ -0,0 +1,510 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. +// see libs/utility/compressed_pair.hpp +// +/* Release notes: + 20 Jan 2001: + Fixed obvious bugs (David Abrahams) + 07 Oct 2000: + Added better single argument constructor support. + 03 Oct 2000: + Added VC6 support (JM). + 23rd July 2000: + Additional comments added. (JM) + Jan 2000: + Original version: this version crippled for use with crippled compilers + - John Maddock Jan 2000. +*/ + + +#ifndef BOOST_OB_COMPRESSED_PAIR_HPP +#define BOOST_OB_COMPRESSED_PAIR_HPP + +#include <algorithm> +#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP +#include <boost/type_traits/object_traits.hpp> +#endif +#ifndef BOOST_SAME_TRAITS_HPP +#include <boost/type_traits/same_traits.hpp> +#endif +#ifndef BOOST_CALL_TRAITS_HPP +#include <boost/call_traits.hpp> +#endif + +namespace boost +{ +#ifdef BOOST_MSVC6_MEMBER_TEMPLATES +// +// use member templates to emulate +// partial specialisation. Note that due to +// problems with overload resolution with VC6 +// each of the compressed_pair versions that follow +// have one template single-argument constructor +// in place of two specific constructors: +// + +template <class T1, class T2> +class compressed_pair; + +namespace detail{ + +template <class A, class T1, class T2> +struct best_conversion_traits +{ + typedef char one; + typedef char (&two)[2]; + static A a; + static one test(T1); + static two test(T2); + + enum { value = sizeof(test(a)) }; +}; + +template <int> +struct init_one; + +template <> +struct init_one<1> +{ + template <class A, class T1, class T2> + static void init(const A& a, T1* p1, T2*) + { + *p1 = a; + } +}; + +template <> +struct init_one<2> +{ + template <class A, class T1, class T2> + static void init(const A& a, T1*, T2* p2) + { + *p2 = a; + } +}; + + +// T1 != T2, both non-empty +template <class T1, class T2> +class compressed_pair_0 +{ +private: + T1 _first; + T2 _second; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_0() : _first(), _second() {} + compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {} + template <class A> + explicit compressed_pair_0(const A& val) + { + init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second); + } + compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x) + : _first(x.first()), _second(x.second()) {} + +#if 0 + compressed_pair_0& operator=(const compressed_pair_0& x) { + cout << "assigning compressed pair 0" << endl; + _first = x._first; + _second = x._second; + cout << "finished assigning compressed pair 0" << endl; + return *this; + } +#endif + + first_reference first() { return _first; } + first_const_reference first() const { return _first; } + + second_reference second() { return _second; } + second_const_reference second() const { return _second; } + + void swap(compressed_pair_0& y) + { + using std::swap; + swap(_first, y._first); + swap(_second, y._second); + } +}; + +// T1 != T2, T2 empty +template <class T1, class T2> +class compressed_pair_1 : T2 +{ +private: + T1 _first; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_1() : T2(), _first() {} + compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {} + + template <class A> + explicit compressed_pair_1(const A& val) + { + init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this)); + } + + compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x) + : T2(x.second()), _first(x.first()) {} + +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + // Total weirdness. If the assignment to _first is moved after + // the call to the inherited operator=, then this breaks graph/test/graph.cpp + // by way of iterator_adaptor. + compressed_pair_1& operator=(const compressed_pair_1& x) { + _first = x._first; + T2::operator=(x); + return *this; + } +#endif + + first_reference first() { return _first; } + first_const_reference first() const { return _first; } + + second_reference second() { return *this; } + second_const_reference second() const { return *this; } + + void swap(compressed_pair_1& y) + { + // no need to swap empty base class: + using std::swap; + swap(_first, y._first); + } +}; + +// T1 != T2, T1 empty +template <class T1, class T2> +class compressed_pair_2 : T1 +{ +private: + T2 _second; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_2() : T1(), _second() {} + compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {} + template <class A> + explicit compressed_pair_2(const A& val) + { + init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second); + } + compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x) + : T1(x.first()), _second(x.second()) {} + +#if 0 + compressed_pair_2& operator=(const compressed_pair_2& x) { + cout << "assigning compressed pair 2" << endl; + T1::operator=(x); + _second = x._second; + cout << "finished assigning compressed pair 2" << endl; + return *this; + } +#endif + first_reference first() { return *this; } + first_const_reference first() const { return *this; } + + second_reference second() { return _second; } + second_const_reference second() const { return _second; } + + void swap(compressed_pair_2& y) + { + // no need to swap empty base class: + using std::swap; + swap(_second, y._second); + } +}; + +// T1 != T2, both empty +template <class T1, class T2> +class compressed_pair_3 : T1, T2 +{ +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_3() : T1(), T2() {} + compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {} + template <class A> + explicit compressed_pair_3(const A& val) + { + init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this)); + } + compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x) + : T1(x.first()), T2(x.second()) {} + + first_reference first() { return *this; } + first_const_reference first() const { return *this; } + + second_reference second() { return *this; } + second_const_reference second() const { return *this; } + + void swap(compressed_pair_3& y) + { + // no need to swap empty base classes: + } +}; + +// T1 == T2, and empty +template <class T1, class T2> +class compressed_pair_4 : T1 +{ +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_4() : T1() {} + compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {} + // only one single argument constructor since T1 == T2 + explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {} + compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x) + : T1(x.first()), m_second(x.second()) {} + + first_reference first() { return *this; } + first_const_reference first() const { return *this; } + + second_reference second() { return m_second; } + second_const_reference second() const { return m_second; } + + void swap(compressed_pair_4& y) + { + // no need to swap empty base classes: + } +private: + T2 m_second; +}; + +// T1 == T2, not empty +template <class T1, class T2> +class compressed_pair_5 +{ +private: + T1 _first; + T2 _second; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair_5() : _first(), _second() {} + compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {} + // only one single argument constructor since T1 == T2 + explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {} + compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) + : _first(c.first()), _second(c.second()) {} + + first_reference first() { return _first; } + first_const_reference first() const { return _first; } + + second_reference second() { return _second; } + second_const_reference second() const { return _second; } + + void swap(compressed_pair_5& y) + { + using std::swap; + swap(_first, y._first); + swap(_second, y._second); + } +}; + +template <bool e1, bool e2, bool same> +struct compressed_pair_chooser +{ + template <class T1, class T2> + struct rebind + { + typedef compressed_pair_0<T1, T2> type; + }; +}; + +template <> +struct compressed_pair_chooser<false, true, false> +{ + template <class T1, class T2> + struct rebind + { + typedef compressed_pair_1<T1, T2> type; + }; +}; + +template <> +struct compressed_pair_chooser<true, false, false> +{ + template <class T1, class T2> + struct rebind + { + typedef compressed_pair_2<T1, T2> type; + }; +}; + +template <> +struct compressed_pair_chooser<true, true, false> +{ + template <class T1, class T2> + struct rebind + { + typedef compressed_pair_3<T1, T2> type; + }; +}; + +template <> +struct compressed_pair_chooser<true, true, true> +{ + template <class T1, class T2> + struct rebind + { + typedef compressed_pair_4<T1, T2> type; + }; +}; + +template <> +struct compressed_pair_chooser<false, false, true> +{ + template <class T1, class T2> + struct rebind + { + typedef compressed_pair_5<T1, T2> type; + }; +}; + +template <class T1, class T2> +struct compressed_pair_traits +{ +private: + typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser; + typedef typename chooser::template rebind<T1, T2> bound_type; +public: + typedef typename bound_type::type type; +}; + +} // namespace detail + +template <class T1, class T2> +class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type +{ +private: + typedef typename detail::compressed_pair_traits<T1, T2>::type base_type; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair() : base_type() {} + compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {} + template <class A> + explicit compressed_pair(const A& x) : base_type(x){} + + first_reference first() { return base_type::first(); } + first_const_reference first() const { return base_type::first(); } + + second_reference second() { return base_type::second(); } + second_const_reference second() const { return base_type::second(); } +}; + +template <class T1, class T2> +inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y) +{ + x.swap(y); +} + +#else +// no partial specialisation, no member templates: + +template <class T1, class T2> +class compressed_pair +{ +private: + T1 _first; + T2 _second; +public: + typedef T1 first_type; + typedef T2 second_type; + typedef typename call_traits<first_type>::param_type first_param_type; + typedef typename call_traits<second_type>::param_type second_param_type; + typedef typename call_traits<first_type>::reference first_reference; + typedef typename call_traits<second_type>::reference second_reference; + typedef typename call_traits<first_type>::const_reference first_const_reference; + typedef typename call_traits<second_type>::const_reference second_const_reference; + + compressed_pair() : _first(), _second() {} + compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {} + explicit compressed_pair(first_param_type x) : _first(x), _second() {} + // can't define this in case T1 == T2: + // explicit compressed_pair(second_param_type y) : _first(), _second(y) {} + + first_reference first() { return _first; } + first_const_reference first() const { return _first; } + + second_reference second() { return _second; } + second_const_reference second() const { return _second; } + + void swap(compressed_pair& y) + { + using std::swap; + swap(_first, y._first); + swap(_second, y._second); + } +}; + +template <class T1, class T2> +inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y) +{ + x.swap(y); +} + +#endif + +} // boost + +#endif // BOOST_OB_COMPRESSED_PAIR_HPP + + + diff --git a/boost/detail/quick_allocator.hpp b/boost/detail/quick_allocator.hpp new file mode 100644 index 0000000000..d54b3a792d --- /dev/null +++ b/boost/detail/quick_allocator.hpp @@ -0,0 +1,23 @@ +#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED +#define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// detail/quick_allocator.hpp +// +// Copyright (c) 2003 David Abrahams +// Copyright (c) 2003 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// + +#include <boost/smart_ptr/detail/quick_allocator.hpp> + +#endif // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED diff --git a/boost/detail/reference_content.hpp b/boost/detail/reference_content.hpp new file mode 100644 index 0000000000..daf56a8b19 --- /dev/null +++ b/boost/detail/reference_content.hpp @@ -0,0 +1,141 @@ +//----------------------------------------------------------------------------- +// boost detail/reference_content.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_REFERENCE_CONTENT_HPP +#define BOOST_DETAIL_REFERENCE_CONTENT_HPP + +#include "boost/config.hpp" + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# include "boost/mpl/bool.hpp" +# include "boost/type_traits/has_nothrow_copy.hpp" +#else +# include "boost/mpl/if.hpp" +# include "boost/type_traits/is_reference.hpp" +#endif + +#include "boost/mpl/void.hpp" + +namespace boost { + +namespace detail { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class template reference_content +// +// Non-Assignable wrapper for references. +// +template <typename RefT> +class reference_content +{ +private: // representation + + RefT content_; + +public: // structors + + ~reference_content() + { + } + + reference_content(RefT r) + : content_( r ) + { + } + + reference_content(const reference_content& operand) + : content_( operand.content_ ) + { + } + +private: // non-Assignable + + reference_content& operator=(const reference_content&); + +public: // queries + + RefT get() const + { + return content_; + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction make_reference_content +// +// Wraps with reference_content if specified type is reference. +// + +template <typename T = mpl::void_> struct make_reference_content; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template <typename T> +struct make_reference_content +{ + typedef T type; +}; + +template <typename T> +struct make_reference_content< T& > +{ + typedef reference_content<T&> type; +}; + +#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template <typename T> +struct make_reference_content + : mpl::if_< + is_reference<T> + , reference_content<T> + , T + > +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround + +template <> +struct make_reference_content< mpl::void_ > +{ + template <typename T> + struct apply + : make_reference_content<T> + { + }; + + typedef mpl::void_ type; +}; + +} // namespace detail + +/////////////////////////////////////////////////////////////////////////////// +// reference_content<T&> type traits specializations +// + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template <typename T> +struct has_nothrow_copy< + ::boost::detail::reference_content< T& > + > + : mpl::true_ +{ +}; + +#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +} // namespace boost + +#endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP diff --git a/boost/detail/scoped_enum_emulation.hpp b/boost/detail/scoped_enum_emulation.hpp new file mode 100644 index 0000000000..e695a20857 --- /dev/null +++ b/boost/detail/scoped_enum_emulation.hpp @@ -0,0 +1,56 @@ +// scoped_enum_emulation.hpp ---------------------------------------------------------// + +// Copyright Beman Dawes, 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Generates C++0x scoped enums if the feature is present, otherwise emulates C++0x +// scoped enums with C++03 namespaces and enums. The Boost.Config BOOST_NO_SCOPED_ENUMS +// macro is used to detect feature support. +// +// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a +// description of the scoped enum feature. Note that the committee changed the name +// from strongly typed enum to scoped enum. +// +// Caution: only the syntax is emulated; the semantics are not emulated and +// the syntax emulation doesn't include being able to specify the underlying +// representation type. +// +// The emulation is via struct rather than namespace to allow use within classes. +// Thanks to Andrey Semashev for pointing that out. +// +// Helpful comments and suggestions were also made by Kjell Elster, Phil Endecott, +// Joel Falcou, Mathias Gaunard, Felipe Magno de Almeida, Matt Calabrese, Vincente +// Botet, and Daniel James. +// +// Sample usage: +// +// BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END +// ... +// BOOST_SCOPED_ENUM(algae) sample( algae::red ); +// void foo( BOOST_SCOPED_ENUM(algae) color ); +// ... +// sample = algae::green; +// foo( algae::cyan ); + +#ifndef BOOST_SCOPED_ENUM_EMULATION_HPP +#define BOOST_SCOPED_ENUM_EMULATION_HPP + +#include <boost/config.hpp> + +#ifdef BOOST_NO_SCOPED_ENUMS + +# define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type +# define BOOST_SCOPED_ENUM_END }; +# define BOOST_SCOPED_ENUM(name) name::enum_type + +#else + +# define BOOST_SCOPED_ENUM_START(name) enum class name +# define BOOST_SCOPED_ENUM_END +# define BOOST_SCOPED_ENUM(name) name + +#endif + +#endif // BOOST_SCOPED_ENUM_EMULATION_HPP diff --git a/boost/detail/select_type.hpp b/boost/detail/select_type.hpp new file mode 100644 index 0000000000..c13946f338 --- /dev/null +++ b/boost/detail/select_type.hpp @@ -0,0 +1,36 @@ +// (C) Copyright David Abrahams 2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org for most recent version including documentation. + +// Revision History +// 09 Feb 01 Applied John Maddock's Borland patch Moving <true> +// specialization to unspecialized template (David Abrahams) +// 06 Feb 01 Created (David Abrahams) + +#ifndef SELECT_TYPE_DWA20010206_HPP +# define SELECT_TYPE_DWA20010206_HPP + +namespace boost { namespace detail { + + // Template class if_true -- select among 2 types based on a bool constant expression + // Usage: + // typename if_true<(bool_const_expression)>::template then<true_type, false_type>::type + + // HP aCC cannot deal with missing names for template value parameters + template <bool b> struct if_true + { + template <class T, class F> + struct then { typedef T type; }; + }; + + template <> + struct if_true<false> + { + template <class T, class F> + struct then { typedef F type; }; + }; +}} +#endif // SELECT_TYPE_DWA20010206_HPP diff --git a/boost/detail/sp_typeinfo.hpp b/boost/detail/sp_typeinfo.hpp new file mode 100644 index 0000000000..43fae78ef1 --- /dev/null +++ b/boost/detail/sp_typeinfo.hpp @@ -0,0 +1,135 @@ +#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED +#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/sp_typeinfo.hpp +// +// Copyright 2007 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/config.hpp> + +#if defined( BOOST_NO_TYPEID ) + +#include <boost/current_function.hpp> +#include <functional> + +namespace boost +{ + +namespace detail +{ + +class sp_typeinfo +{ +private: + + sp_typeinfo( sp_typeinfo const& ); + sp_typeinfo& operator=( sp_typeinfo const& ); + + char const * name_; + +public: + + explicit sp_typeinfo( char const * name ): name_( name ) + { + } + + bool operator==( sp_typeinfo const& rhs ) const + { + return this == &rhs; + } + + bool operator!=( sp_typeinfo const& rhs ) const + { + return this != &rhs; + } + + bool before( sp_typeinfo const& rhs ) const + { + return std::less< sp_typeinfo const* >()( this, &rhs ); + } + + char const* name() const + { + return name_; + } +}; + +template<class T> struct sp_typeid_ +{ + static sp_typeinfo ti_; + + static char const * name() + { + return BOOST_CURRENT_FUNCTION; + } +}; + +#if defined(__SUNPRO_CC) +// see #4199, the Sun Studio compiler gets confused about static initialization +// constructor arguments. But an assignment works just fine. +template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name(); +#else +template<class T> sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name()); +#endif + +template<class T> struct sp_typeid_< T & >: sp_typeid_< T > +{ +}; + +template<class T> struct sp_typeid_< T const >: sp_typeid_< T > +{ +}; + +template<class T> struct sp_typeid_< T volatile >: sp_typeid_< T > +{ +}; + +template<class T> struct sp_typeid_< T const volatile >: sp_typeid_< T > +{ +}; + +} // namespace detail + +} // namespace boost + +#define BOOST_SP_TYPEID(T) (boost::detail::sp_typeid_<T>::ti_) + +#else + +#include <typeinfo> + +namespace boost +{ + +namespace detail +{ + +#if defined( BOOST_NO_STD_TYPEINFO ) + +typedef ::type_info sp_typeinfo; + +#else + +typedef std::type_info sp_typeinfo; + +#endif + +} // namespace detail + +} // namespace boost + +#define BOOST_SP_TYPEID(T) typeid(T) + +#endif + +#endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED diff --git a/boost/detail/templated_streams.hpp b/boost/detail/templated_streams.hpp new file mode 100644 index 0000000000..1fa6ee3534 --- /dev/null +++ b/boost/detail/templated_streams.hpp @@ -0,0 +1,74 @@ +//----------------------------------------------------------------------------- +// boost detail/templated_streams.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_TEMPLATED_STREAMS_HPP +#define BOOST_DETAIL_TEMPLATED_STREAMS_HPP + +#include "boost/config.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// (detail) BOOST_TEMPLATED_STREAM_* macros +// +// Provides workaround platforms without stream class templates. +// + +#if !defined(BOOST_NO_STD_LOCALE) + +#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) \ + template < typename E , typename T > + +#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) \ + template < typename E , typename T , typename A > + +#define BOOST_TEMPLATED_STREAM_ARGS(E,T) \ + typename E , typename T + +#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) \ + typename E , typename T , typename A + +#define BOOST_TEMPLATED_STREAM_COMMA , + +#define BOOST_TEMPLATED_STREAM_ELEM(E) E +#define BOOST_TEMPLATED_STREAM_TRAITS(T) T +#define BOOST_TEMPLATED_STREAM_ALLOC(A) A + +#define BOOST_TEMPLATED_STREAM(X,E,T) \ + BOOST_JOIN(std::basic_,X)< E , T > + +#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ + BOOST_JOIN(std::basic_,X)< E , T , A > + +#else // defined(BOOST_NO_STD_LOCALE) + +#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) /**/ + +#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) /**/ + +#define BOOST_TEMPLATED_STREAM_ARGS(E,T) /**/ + +#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) /**/ + +#define BOOST_TEMPLATED_STREAM_COMMA /**/ + +#define BOOST_TEMPLATED_STREAM_ELEM(E) char +#define BOOST_TEMPLATED_STREAM_TRAITS(T) std::char_traits<char> +#define BOOST_TEMPLATED_STREAM_ALLOC(A) std::allocator<char> + +#define BOOST_TEMPLATED_STREAM(X,E,T) \ + std::X + +#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ + std::X + +#endif // BOOST_NO_STD_LOCALE + +#endif // BOOST_DETAIL_TEMPLATED_STREAMS_HPP diff --git a/boost/detail/utf8_codecvt_facet.hpp b/boost/detail/utf8_codecvt_facet.hpp new file mode 100644 index 0000000000..b777ff934e --- /dev/null +++ b/boost/detail/utf8_codecvt_facet.hpp @@ -0,0 +1,190 @@ +// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) +// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). +// Distributed under the Boost Software License, Version 1.0. (See accompany- +// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_UTF8_CODECVT_FACET_HPP +#define BOOST_UTF8_CODECVT_FACET_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// utf8_codecvt_facet.hpp + +// This header defines class utf8_codecvt_facet, derived fro +// std::codecvt<wchar_t, char>, which can be used to convert utf8 data in +// files into wchar_t strings in the application. +// +// The header is NOT STANDALONE, and is not to be included by the USER. +// There are at least two libraries which want to use this functionality, and +// we want to avoid code duplication. It would be possible to create utf8 +// library, but: +// - this requires review process first +// - in the case, when linking the a library which uses utf8 +// (say 'program_options'), user should also link to the utf8 library. +// This seems inconvenient, and asking a user to link to an unrevieved +// library is strange. +// Until the above points are fixed, a library which wants to use utf8 must: +// - include this header from one of it's headers or sources +// - include the corresponding .cpp file from one of the sources +// - before including either file, the library must define +// - BOOST_UTF8_BEGIN_NAMESPACE to the namespace declaration that must be used +// - BOOST_UTF8_END_NAMESPACE to the code to close the previous namespace +// - declaration. +// - BOOST_UTF8_DECL -- to the code which must be used for all 'exportable' +// symbols. +// +// For example, program_options library might contain: +// #define BOOST_UTF8_BEGIN_NAMESPACE <backslash character> +// namespace boost { namespace program_options { +// #define BOOST_UTF8_END_NAMESPACE }} +// #define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL +// #include "../../detail/utf8/utf8_codecvt.cpp" +// +// Essentially, each library will have its own copy of utf8 code, in +// different namespaces. + +// Note:(Robert Ramey). I have made the following alterations in the original +// code. +// a) Rendered utf8_codecvt<wchar_t, char> with using templates +// b) Move longer functions outside class definition to prevent inlining +// and make code smaller +// c) added on a derived class to permit translation to/from current +// locale to utf8 + +// See http://www.boost.org for updates, documentation, and revision history. + +// archives stored as text - note these ar templated on the basic +// stream templates to accommodate wide (and other?) kind of characters +// +// note the fact that on libraries without wide characters, ostream is +// is not a specialization of basic_ostream which in fact is not defined +// in such cases. So we can't use basic_ostream<OStream::char_type> but rather +// use two template parameters +// +// utf8_codecvt_facet +// This is an implementation of a std::codecvt facet for translating +// from UTF-8 externally to UCS-4. Note that this is not tied to +// any specific types in order to allow customization on platforms +// where wchar_t is not big enough. +// +// NOTES: The current implementation jumps through some unpleasant hoops in +// order to deal with signed character types. As a std::codecvt_base::result, +// it is necessary for the ExternType to be convertible to unsigned char. +// I chose not to tie the extern_type explicitly to char. But if any combination +// of types other than <wchar_t,char_t> is used, then std::codecvt must be +// specialized on those types for this to work. + +#include <locale> +#include <cwchar> // for mbstate_t +#include <cstddef> // for std::size_t + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std { + using ::mbstate_t; + using ::size_t; +} +#endif + +#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__) + #define BOOST_CODECVT_DO_LENGTH_CONST const +#else + #define BOOST_CODECVT_DO_LENGTH_CONST +#endif + +// maximum lenght of a multibyte string +#define MB_LENGTH_MAX 8 + +BOOST_UTF8_BEGIN_NAMESPACE + +struct BOOST_UTF8_DECL utf8_codecvt_facet : + public std::codecvt<wchar_t, char, std::mbstate_t> +{ +public: + explicit utf8_codecvt_facet(std::size_t no_locale_manage=0) + : std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage) + {} +protected: + virtual std::codecvt_base::result do_in( + std::mbstate_t& state, + const char * from, + const char * from_end, + const char * & from_next, + wchar_t * to, + wchar_t * to_end, + wchar_t*& to_next + ) const; + + virtual std::codecvt_base::result do_out( + std::mbstate_t & state, const wchar_t * from, + const wchar_t * from_end, const wchar_t* & from_next, + char * to, char * to_end, char * & to_next + ) const; + + bool invalid_continuing_octet(unsigned char octet_1) const { + return (octet_1 < 0x80|| 0xbf< octet_1); + } + + bool invalid_leading_octet(unsigned char octet_1) const { + return (0x7f < octet_1 && octet_1 < 0xc0) || + (octet_1 > 0xfd); + } + + // continuing octets = octets except for the leading octet + static unsigned int get_cont_octet_count(unsigned char lead_octet) { + return get_octet_count(lead_octet) - 1; + } + + static unsigned int get_octet_count(unsigned char lead_octet); + + // How many "continuing octets" will be needed for this word + // == total octets - 1. + int get_cont_octet_out_count(wchar_t word) const ; + + virtual bool do_always_noconv() const throw() { return false; } + + // UTF-8 isn't really stateful since we rewind on partial conversions + virtual std::codecvt_base::result do_unshift( + std::mbstate_t&, + char * from, + char * /*to*/, + char * & next + ) const + { + next = from; + return ok; + } + + virtual int do_encoding() const throw() { + const int variable_byte_external_encoding=0; + return variable_byte_external_encoding; + } + + // How many char objects can I process to get <= max_limit + // wchar_t objects? + virtual int do_length( + BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &, + const char * from, + const char * from_end, + std::size_t max_limit +#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) + ) const throw(); +#else + ) const; +#endif + + // Largest possible value do_length(state,from,from_end,1) could return. + virtual int do_max_length() const throw () { + return 6; // largest UTF-8 encoding of a UCS-4 character + } +}; + +BOOST_UTF8_END_NAMESPACE + +#endif // BOOST_UTF8_CODECVT_FACET_HPP diff --git a/boost/detail/win/GetCurrentProcess.hpp b/boost/detail/win/GetCurrentProcess.hpp new file mode 100644 index 0000000000..a76eb06e8f --- /dev/null +++ b/boost/detail/win/GetCurrentProcess.hpp @@ -0,0 +1,25 @@ +// GetCurrentProcess.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_GETCURRENTPROCESS_HPP +#define BOOST_DETAIL_WIN_GETCURRENTPROCESS_HPP + +#include <boost/detail/win/basic_types.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetCurrentProcess; +#else + extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentProcess(); +#endif +} +} +} +#endif // BOOST_DETAIL_WIN_TIME_HPP diff --git a/boost/detail/win/GetCurrentThread.hpp b/boost/detail/win/GetCurrentThread.hpp new file mode 100644 index 0000000000..cdc6d36c78 --- /dev/null +++ b/boost/detail/win/GetCurrentThread.hpp @@ -0,0 +1,34 @@ +// GetCurrentThread.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_GETCURRENTTHREAD_HPP +#define BOOST_DETAIL_WIN_GETCURRENTTHREAD_HPP + +#include <boost/detail/win/basic_types.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( UNDER_CE ) +// Windows CE define GetCurrentThread as an inline function in kfuncs.h +inline HANDLE_ GetCurrentThread() +{ + return ::GetCurrentThread(); +} +#else +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetCurrentThread; +#else + extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentThread(); +#endif +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_TIME_HPP diff --git a/boost/detail/win/GetLastError.hpp b/boost/detail/win/GetLastError.hpp new file mode 100644 index 0000000000..d040abf50d --- /dev/null +++ b/boost/detail/win/GetLastError.hpp @@ -0,0 +1,27 @@ +// GetLastError.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_GETLASTERROR_HPP +#define BOOST_DETAIL_WIN_GETLASTERROR_HPP + +#include <boost/detail/win/basic_types.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetLastError; +#else + extern "C" __declspec(dllimport) DWORD_ WINAPI + GetLastError(); +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_TIME_HPP diff --git a/boost/detail/win/GetProcessTimes.hpp b/boost/detail/win/GetProcessTimes.hpp new file mode 100644 index 0000000000..8d76995893 --- /dev/null +++ b/boost/detail/win/GetProcessTimes.hpp @@ -0,0 +1,35 @@ +// GetProcessTimes.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP +#define BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP + +#include <boost/detail/win/time.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if !defined(UNDER_CE) // Windows CE does not define GetProcessTimes +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetProcessTimes; +#else + extern "C" __declspec(dllimport) BOOL_ WINAPI + GetProcessTimes( + HANDLE_ hProcess, + LPFILETIME_ lpCreationTime, + LPFILETIME_ lpExitTime, + LPFILETIME_ lpKernelTime, + LPFILETIME_ lpUserTime + ); +#endif +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP diff --git a/boost/detail/win/GetThreadTimes.hpp b/boost/detail/win/GetThreadTimes.hpp new file mode 100644 index 0000000000..cf19c462ed --- /dev/null +++ b/boost/detail/win/GetThreadTimes.hpp @@ -0,0 +1,33 @@ +// GetThreadTimes.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_GETTHREADTIMES_HPP +#define BOOST_DETAIL_WIN_GETTHREADTIMES_HPP + +#include <boost/detail/win/time.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetThreadTimes; +#else + extern "C" __declspec(dllimport) BOOL_ WINAPI + GetThreadTimes( + HANDLE_ hThread, + LPFILETIME_ lpCreationTime, + LPFILETIME_ lpExitTime, + LPFILETIME_ lpKernelTime, + LPFILETIME_ lpUserTime + ); +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_GETTHREADTIMES_HPP diff --git a/boost/detail/win/LocalFree.hpp b/boost/detail/win/LocalFree.hpp new file mode 100644 index 0000000000..da1c77b669 --- /dev/null +++ b/boost/detail/win/LocalFree.hpp @@ -0,0 +1,29 @@ +// LocalFree.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_LOCALFREE_HPP +#define BOOST_DETAIL_WIN_LOCALFREE_HPP + +#include <boost/detail/win/basic_types.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + typedef HANDLE_ HLOCAL_; + + using ::LocalFree; +#else + extern "C" typedef HANDLE_ HLOCAL_; + extern "C" __declspec(dllimport) HLOCAL_ WINAPI + LocalFree(HLOCAL_ hMem); +#endif +} +} +} +#endif // BOOST_DETAIL_WIN_LOCALFREE_HPP diff --git a/boost/detail/win/basic_types.hpp b/boost/detail/win/basic_types.hpp new file mode 100644 index 0000000000..f4e34721cf --- /dev/null +++ b/boost/detail/win/basic_types.hpp @@ -0,0 +1,111 @@ +// basic_types.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_BASIC_TYPES_HPP +#define BOOST_DETAIL_WIN_BASIC_TYPES_HPP +#include <boost/config.hpp> +#include <cstdarg> +#include <boost/cstdint.hpp> +#if defined( BOOST_USE_WINDOWS_H ) +# include <windows.h> +#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined(__CYGWIN__) +# include <WinError.h> +// @FIXME Which condition must be tested +# ifdef UNDER_CE +# ifndef WINAPI +# ifndef _WIN32_WCE_EMULATION +# define WINAPI __cdecl // Note this doesn't match the desktop definition +# else +# define WINAPI __stdcall +# endif +# endif +# else +# ifndef WINAPI +# define WINAPI __stdcall +# endif +# endif +#else +# error "Win32 functions not available" +#endif + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + typedef ::BOOL BOOL_; + typedef ::WORD WORD_; + typedef ::DWORD DWORD_; + typedef ::HANDLE HANDLE_; + typedef ::LONG LONG_; + typedef ::LONGLONG LONGLONG_; + typedef ::ULONG_PTR ULONG_PTR_; + typedef ::LARGE_INTEGER LARGE_INTEGER_; + typedef ::PLARGE_INTEGER PLARGE_INTEGER_; + typedef ::PVOID PVOID_; + typedef ::LPVOID LPVOID_; + typedef ::CHAR CHAR_; + typedef ::LPSTR LPSTR_; + typedef ::LPCSTR LPCSTR_; + typedef ::WCHAR WCHAR_; + typedef ::LPWSTR LPWSTR_; + typedef ::LPCWSTR LPCWSTR_; +#else +extern "C" { + typedef int BOOL_; + typedef unsigned short WORD_; + typedef unsigned long DWORD_; + typedef void* HANDLE_; + + typedef long LONG_; + +// @FIXME Which condition must be tested +//~ #if !defined(_M_IX86) +//~ #if defined(BOOST_NO_INT64_T) + //~ typedef double LONGLONG_; +//~ #else + //~ typedef __int64 LONGLONG_; +//~ #endif +//~ #else + //~ typedef double LONGLONG_; +//~ #endif + typedef boost::int64_t LONGLONG_; + +// @FIXME Which condition must be tested +# ifdef _WIN64 +#if defined(__CYGWIN__) + typedef unsigned long ULONG_PTR_; +#else + typedef unsigned __int64 ULONG_PTR_; +#endif +# else + typedef unsigned long ULONG_PTR_; +# endif + + typedef struct _LARGE_INTEGER { + LONGLONG_ QuadPart; + } LARGE_INTEGER_; + typedef LARGE_INTEGER_ *PLARGE_INTEGER_; + + typedef void *PVOID_; + typedef void *LPVOID_; + typedef const void *LPCVOID_; + + typedef char CHAR_; + typedef CHAR_ *LPSTR_; + typedef const CHAR_ *LPCSTR_; + + typedef wchar_t WCHAR_; + typedef WCHAR_ *LPWSTR_; + typedef const WCHAR_ *LPCWSTR_; + +} +#endif +} +} +} +#endif // BOOST_DETAIL_WIN_TIME_HPP diff --git a/boost/detail/win/directory_management.hpp b/boost/detail/win/directory_management.hpp new file mode 100644 index 0000000000..1ffe659766 --- /dev/null +++ b/boost/detail/win/directory_management.hpp @@ -0,0 +1,43 @@ +// directory_management.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_DIRECTORY_MANAGEMENT_HPP +#define BOOST_DETAIL_WIN_DIRECTORY_MANAGEMENT_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/security.hpp> + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::CreateDirectory; + using ::CreateDirectoryA; + using ::GetTempPathA; + using ::RemoveDirectoryA; +#else +extern "C" { + __declspec(dllimport) int __stdcall + CreateDirectory(LPCTSTR_, LPSECURITY_ATTRIBUTES_*); + __declspec(dllimport) int __stdcall + CreateDirectoryA(LPCTSTR_, interprocess_security_attributes*); + __declspec(dllimport) int __stdcall + GetTempPathA(unsigned long length, char *buffer); + __declspec(dllimport) int __stdcall + RemoveDirectoryA(LPCTSTR_); + +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_THREAD_HPP diff --git a/boost/detail/win/dll.hpp b/boost/detail/win/dll.hpp new file mode 100644 index 0000000000..605a1bf596 --- /dev/null +++ b/boost/detail/win/dll.hpp @@ -0,0 +1,52 @@ +// dll.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_DLL_HPP +#define BOOST_DETAIL_WIN_DLL_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/security.hpp> + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::LoadLibrary; + using ::FreeLibrary; + using ::GetProcAddress; + using ::GetModuleHandleA; +#else +extern "C" { + __declspec(dllimport) HMODULE_ __stdcall + LoadLibrary( + LPCTSTR_ lpFileName + ); + __declspec(dllimport) BOOL_ __stdcall + FreeLibrary( + HMODULE_ hModule + ); + __declspec(dllimport) FARPROC_ __stdcall + GetProcAddress( + HMODULE_ hModule, + LPCSTR_ lpProcName + ); + __declspec(dllimport) FARPROC_ __stdcall + GetModuleHandleA( + LPCSTR_ lpProcName + ); + +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_THREAD_HPP diff --git a/boost/detail/win/error_handling.hpp b/boost/detail/win/error_handling.hpp new file mode 100644 index 0000000000..d6fb428a76 --- /dev/null +++ b/boost/detail/win/error_handling.hpp @@ -0,0 +1,88 @@ +// error_handling.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_ERROR_HANDLING_HPP +#define BOOST_DETAIL_WIN_ERROR_HANDLING_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/GetCurrentThread.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + using ::FormatMessageA; + using ::FormatMessageW; + + const int FORMAT_MESSAGE_ALLOCATE_BUFFER_= FORMAT_MESSAGE_ALLOCATE_BUFFER; + const int FORMAT_MESSAGE_IGNORE_INSERTS_= FORMAT_MESSAGE_IGNORE_INSERTS; + const int FORMAT_MESSAGE_FROM_STRING_= FORMAT_MESSAGE_FROM_STRING; + const int FORMAT_MESSAGE_FROM_HMODULE_= FORMAT_MESSAGE_FROM_HMODULE; + const int FORMAT_MESSAGE_FROM_SYSTEM_= FORMAT_MESSAGE_FROM_SYSTEM; + const int FORMAT_MESSAGE_ARGUMENT_ARRAY_= FORMAT_MESSAGE_ARGUMENT_ARRAY; + const int FORMAT_MESSAGE_MAX_WIDTH_MASK_= FORMAT_MESSAGE_MAX_WIDTH_MASK; + + const char LANG_NEUTRAL_= LANG_NEUTRAL; + const char LANG_INVARIANT_= LANG_INVARIANT; + + const char SUBLANG_DEFAULT_= SUBLANG_DEFAULT; // user default + inline WORD_ MAKELANGID_(WORD_ p, WORD_ s) { + return MAKELANGID(p,s); + } +#else +extern "C" { + // using ::FormatMessageA; + __declspec(dllimport) + DWORD_ + WINAPI + FormatMessageA( + DWORD_ dwFlags, + LPCVOID_ lpSource, + DWORD_ dwMessageId, + DWORD_ dwLanguageId, + LPSTR_ lpBuffer, + DWORD_ nSize, + va_list *Arguments + ); + + // using ::FormatMessageW; + __declspec(dllimport) + DWORD_ + WINAPI + FormatMessageW( + DWORD_ dwFlags, + LPCVOID_ lpSource, + DWORD_ dwMessageId, + DWORD_ dwLanguageId, + LPWSTR_ lpBuffer, + DWORD_ nSize, + va_list *Arguments + ); + + const int FORMAT_MESSAGE_ALLOCATE_BUFFER_= 0x00000100; + const int FORMAT_MESSAGE_IGNORE_INSERTS_= 0x00000200; + const int FORMAT_MESSAGE_FROM_STRING_= 0x00000400; + const int FORMAT_MESSAGE_FROM_HMODULE_= 0x00000800; + const int FORMAT_MESSAGE_FROM_SYSTEM_= 0x00001000; + const int FORMAT_MESSAGE_ARGUMENT_ARRAY_= 0x00002000; + const int FORMAT_MESSAGE_MAX_WIDTH_MASK_= 0x000000FF; + + const char LANG_NEUTRAL_= 0x00; + const char LANG_INVARIANT_= 0x7f; + + const char SUBLANG_DEFAULT_= 0x01; // user default + inline WORD_ MAKELANGID_(WORD_ p, WORD_ s) { + return ((((WORD_ )(s)) << 10) | (WORD_ )(p)); + } + +} +#endif +} +} +} +#endif // BOOST_DETAIL_WIN_ERROR_HANDLING_HPP diff --git a/boost/detail/win/file_management.hpp b/boost/detail/win/file_management.hpp new file mode 100644 index 0000000000..5cb0dbff29 --- /dev/null +++ b/boost/detail/win/file_management.hpp @@ -0,0 +1,126 @@ +// thread.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_FILE_MANAGEMENT_HPP +#define BOOST_DETAIL_WIN_FILE_MANAGEMENT_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/security.hpp> + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::CreateFileA; + using ::DeleteFileA; + using ::FindFirstFileA; + using ::FindNextFileA; + using ::FindClose; + using ::GetFileSizeEx; + using ::MoveFileExA; + using ::SetFileValidData; +#else +extern "C" { + typedef struct _OVERLAPPED { + ULONG_PTR Internal; + ULONG_PTR InternalHigh; + union { + struct { + DWORD Offset; + DWORD OffsetHigh; + } ; + PVOID Pointer; + } ; + HANDLE hEvent; + } OVERLAPPED, *LPOVERLAPPED; + + + __declspec(dllimport) void * __stdcall + CreateFileA (const char *, unsigned long, unsigned long, struct SECURITY_ATTRIBUTES_*, unsigned long, unsigned long, void *); + __declspec(dllimport) int __stdcall + DeleteFileA (const char *); + __declspec(dllimport) void *__stdcall + FindFirstFileA(const char *lpFileName, win32_find_data_t *lpFindFileData); + __declspec(dllimport) int __stdcall + FindNextFileA(void *hFindFile, win32_find_data_t *lpFindFileData); + __declspec(dllimport) int __stdcall + FindClose(void *hFindFile); + __declspec(dllimport) BOOL __stdcall + GetFileSizeEx( + HANDLE_ hFile, + PLARGE_INTEGER_ lpFileSize + ); + __declspec(dllimport) int __stdcall + MoveFileExA (const char *, const char *, unsigned long); + __declspec(dllimport) BOOL_ __stdcall + SetFileValidData( + HANDLE_ hFile, + LONGLONG_ ValidDataLength + ); + __declspec(dllimport) BOOL_ __stdcall + SetEndOfFile( + HANDLE_ hFile + ); + __declspec(dllimport) BOOL_ __stdcall + SetFilePointerEx( + HANDLE_ hFile, + LARGE_INTEGER_ liDistanceToMove, + PLARGE_INTEGER_ lpNewFilePointer, + DWORD_ dwMoveMethod + ); + __declspec(dllimport) BOOL_ __stdcall + LockFile( + HANDLE_ hFile, + DWORD_ dwFileOffsetLow, + DWORD_ dwFileOffsetHigh, + DWORD_ nNumberOfBytesToLockLow, + DWORD_ nNumberOfBytesToLockHigh + ); + __declspec(dllimport) BOOL_ __stdcall + UnlockFile( + HANDLE_ hFile, + DWORD_ dwFileOffsetLow, + DWORD_ dwFileOffsetHigh, + DWORD_ nNumberOfBytesToUnlockLow, + DWORD_ nNumberOfBytesToUnlockHigh + ); + __declspec(dllimport) BOOL_ __stdcall + LockFileEx( + HANDLE_ hFile, + DWORD_ dwFlags, + DWORD_ dwReserved, + DWORD_ nNumberOfBytesToLockLow, + DWORD_ nNumberOfBytesToLockHigh, + LPOVERLAPPED_ lpOverlapped + ); + __declspec(dllimport) BOOL_ __stdcall + UnlockFileEx( + HANDLE_ hFile, + DWORD_ dwReserved, + DWORD_ nNumberOfBytesToUnlockLow, + DWORD_ nNumberOfBytesToUnlockHigh, + LPOVERLAPPED_ lpOverlapped + ); + __declspec(dllimport) BOOL_ __stdcall + WriteFile( + HANDLE_ hFile, + LPCVOID_ lpBuffer, + DWORD_ nNumberOfBytesToWrite, + LPDWORD_ lpNumberOfBytesWritten, + LPOVERLAPPED_ lpOverlapped + ); +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_THREAD_HPP diff --git a/boost/detail/win/handles.hpp b/boost/detail/win/handles.hpp new file mode 100644 index 0000000000..1441d10a2c --- /dev/null +++ b/boost/detail/win/handles.hpp @@ -0,0 +1,37 @@ +// memory.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_HANDLES_HPP +#define BOOST_DETAIL_WIN_HANDLES_HPP + +#include <boost/detail/win/basic_types.hpp> + + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::CloseHandle; + using ::DuplicateHandle; +#else +extern "C" { + __declspec(dllimport) int __stdcall + CloseHandle(void*); + __declspec(dllimport) int __stdcall + DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long); +} + +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_HANDLES_HPP diff --git a/boost/detail/win/memory.hpp b/boost/detail/win/memory.hpp new file mode 100644 index 0000000000..8bf59ad87e --- /dev/null +++ b/boost/detail/win/memory.hpp @@ -0,0 +1,59 @@ +// memory.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_MEMORY_HPP +#define BOOST_DETAIL_WIN_MEMORY_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/security.hpp> +#include <boost/detail/win/LocalFree.hpp> + + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::CreateFileMappingA; + using ::FlushViewOfFile; + using ::GetProcessHeap; + using ::HeapAlloc; + using ::HeapFree; + using ::MapViewOfFileEx; + using ::OpenFileMappingA; + using ::UnmapViewOfFile; +#else +# ifdef HeapAlloc +# undef HeapAlloc +# endif +extern "C" { + __declspec(dllimport) void * __stdcall + CreateFileMappingA (void *, SECURITY_ATTRIBUTES_*, unsigned long, unsigned long, unsigned long, const char *); + __declspec(dllimport) int __stdcall + FlushViewOfFile (void *, std::size_t); + __declspec(dllimport) HANDLE_ __stdcall + GetProcessHeap(); + __declspec(dllimport) void* __stdcall + HeapAlloc(HANDLE_,DWORD_,SIZE_T_); + __declspec(dllimport) BOOL_ __stdcall + HeapFree(HANDLE_,DWORD_,LPVOID_); + __declspec(dllimport) void * __stdcall + MapViewOfFileEx (void *, unsigned long, unsigned long, unsigned long, std::size_t, void*); + __declspec(dllimport) void * __stdcall + OpenFileMappingA (unsigned long, int, const char *); + __declspec(dllimport) int __stdcall + UnmapViewOfFile(void *); +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP diff --git a/boost/detail/win/process.hpp b/boost/detail/win/process.hpp new file mode 100644 index 0000000000..10c3a9392c --- /dev/null +++ b/boost/detail/win/process.hpp @@ -0,0 +1,33 @@ +// process.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_PROCESS_HPP +#define BOOST_DETAIL_WIN_PROCESS_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/GetCurrentProcess.hpp> + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetCurrentProcessId; +#else +# ifndef UNDER_CE +extern "C" { + __declspec(dllimport) unsigned long __stdcall + GetCurrentProcessId(void); +} +# else + using ::GetCurrentProcessId; +# endif +#endif +} +} +} +#endif // BOOST_DETAIL_WIN_PROCESS_HPP diff --git a/boost/detail/win/security.hpp b/boost/detail/win/security.hpp new file mode 100644 index 0000000000..ee38985193 --- /dev/null +++ b/boost/detail/win/security.hpp @@ -0,0 +1,62 @@ +// security.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_SECURITY_HPP +#define BOOST_DETAIL_WIN_SECURITY_HPP + +#include <boost/detail/win/basic_types.hpp> + + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) +typedef ::SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES_; +typedef ::PSECURITY_ATTRIBUTES PSECURITY_ATTRIBUTES_; +typedef ::LPSECURITY_ATTRIBUTES LPSECURITY_ATTRIBUTES_; + +#else +extern "C" { + struct SECURITY_DESCRIPTOR_; + typedef SECURITY_DESCRIPTOR_* PSECURITY_DESCRIPTOR_; + typedef struct _ACL { + BYTE_ AclRevision; + BYTE_ Sbz1; + WORD_ AclSize; + WORD_ AceCount; + WORD_ Sbz2; + } ACL_, *PACL_; + + typedef struct _SECURITY_ATTRIBUTES { + DWORD_ nLength; + LPVOID_ lpSecurityDescriptor; + BOOL_ bInheritHandle; + } SECURITY_ATTRIBUTES_, *PSECURITY_ATTRIBUTES_, *LPSECURITY_ATTRIBUTES_; + + __declspec(dllimport) BOOL_ __stdcall + InitializeSecurityDescriptor( + PSECURITY_DESCRIPTOR_ pSecurityDescriptor, + DWORD_ dwRevision + ); + __declspec(dllimport) BOOL_ __stdcall + SetSecurityDescriptorDacl( + PSECURITY_DESCRIPTOR_ pSecurityDescriptor, + BOOL_ bDaclPresent, + PACL_ pDacl, + BOOL_ bDaclDefaulted + ); +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_SECURITY_HPP diff --git a/boost/detail/win/synchronization.hpp b/boost/detail/win/synchronization.hpp new file mode 100644 index 0000000000..8fe015b353 --- /dev/null +++ b/boost/detail/win/synchronization.hpp @@ -0,0 +1,125 @@ +// synchronizaion.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP +#define BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP + +#include <boost/detail/win/basic_types.hpp> + + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + typedef ::CRITICAL_SECTION CRITICAL_SECTION_; + typedef ::PAPCFUNC PAPCFUNC_; + + using ::InitializeCriticalSection; + using ::EnterCriticalSection; + using ::TryEnterCriticalSection; + using ::LeaveCriticalSection; + using ::DeleteCriticalSection; + +# ifdef BOOST_NO_ANSI_APIS + using ::CreateMutexW; + using ::CreateEventW; + using ::OpenEventW; + using ::CreateSemaphoreW; +# else + using ::CreateMutexA; + using ::CreateEventA; + using ::OpenEventA; + using ::CreateSemaphoreA; +# endif + using ::ReleaseMutex; + using ::ReleaseSemaphore; + using ::SetEvent; + using ::ResetEvent; + using ::WaitForMultipleObjects; + using ::WaitForSingleObject; + using ::QueueUserAPC; +#else +extern "C" { + struct CRITICAL_SECTION_ + { + struct critical_section_debug * DebugInfo; + long LockCount; + long RecursionCount; + void * OwningThread; + void * LockSemaphore; + #if defined(_WIN64) + unsigned __int64 SpinCount; + #else + unsigned long SpinCount; + #endif + }; + + __declspec(dllimport) void __stdcall + InitializeCriticalSection(CRITICAL_SECTION_ *); + __declspec(dllimport) void __stdcall + EnterCriticalSection(CRITICAL_SECTION_ *); + __declspec(dllimport) bool __stdcall + TryEnterCriticalSection(CRITICAL_SECTION_ *); + __declspec(dllimport) void __stdcall + LeaveCriticalSection(CRITICAL_SECTION_ *); + __declspec(dllimport) void __stdcall + DeleteCriticalSection(CRITICAL_SECTION_ *); + + struct _SECURITY_ATTRIBUTES; +# ifdef BOOST_NO_ANSI_APIS + __declspec(dllimport) void* __stdcall + CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*); + __declspec(dllimport) void* __stdcall + CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*); + __declspec(dllimport) void* __stdcall + CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*); + __declspec(dllimport) void* __stdcall + OpenEventW(unsigned long,int,wchar_t const*); +# else + __declspec(dllimport) void* __stdcall + CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*); + __declspec(dllimport) void* __stdcall + CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*); + __declspec(dllimport) void* __stdcall + CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*); + __declspec(dllimport) void* __stdcall + OpenEventA(unsigned long,int,char const*); +# endif + __declspec(dllimport) int __stdcall + ReleaseMutex(void*); + __declspec(dllimport) unsigned long __stdcall + WaitForSingleObject(void*,unsigned long); + __declspec(dllimport) unsigned long __stdcall + WaitForMultipleObjects(unsigned long nCount, + void* const * lpHandles, + int bWaitAll, + unsigned long dwMilliseconds); + __declspec(dllimport) int __stdcall + ReleaseSemaphore(void*,long,long*); + typedef void (__stdcall *PAPCFUNC8)(ulong_ptr); + __declspec(dllimport) unsigned long __stdcall + QueueUserAPC(PAPCFUNC8,void*,ulong_ptr); +# ifndef UNDER_CE + __declspec(dllimport) int __stdcall + SetEvent(void*); + __declspec(dllimport) int __stdcall + ResetEvent(void*); +# else + using ::SetEvent; + using ::ResetEvent; +# endif +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP diff --git a/boost/detail/win/system.hpp b/boost/detail/win/system.hpp new file mode 100644 index 0000000000..3bcffcec8e --- /dev/null +++ b/boost/detail/win/system.hpp @@ -0,0 +1,50 @@ +// system.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_SYSTEM_HPP +#define BOOST_DETAIL_WIN_SYSTEM_HPP +#include <boost/config.hpp> +#include <cstdarg> + +#include <boost/detail/win/basic_types.hpp> +extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *); + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + typedef ::SYSTEM_INFO SYSTEM_INFO_; +#else +extern "C" { + typedef struct _SYSTEM_INFO { + union { + DWORD_ dwOemId; + struct { + WORD_ wProcessorArchitecture; + WORD_ wReserved; + } dummy; + } ; + DWORD_ dwPageSize; + LPVOID_ lpMinimumApplicationAddress; + LPVOID_ lpMaximumApplicationAddress; + DWORD_PTR_ dwActiveProcessorMask; + DWORD_ dwNumberOfProcessors; + DWORD_ dwProcessorType; + DWORD_ dwAllocationGranularity; + WORD_ wProcessorLevel; + WORD_ wProcessorRevision; + } SYSTEM_INFO_; + + __declspec(dllimport) void __stdcall + GetSystemInfo (struct system_info *); +} +#endif +} +} +} +#endif // BOOST_DETAIL_WIN_TIME_HPP diff --git a/boost/detail/win/thread.hpp b/boost/detail/win/thread.hpp new file mode 100644 index 0000000000..4e1bf307f9 --- /dev/null +++ b/boost/detail/win/thread.hpp @@ -0,0 +1,45 @@ +// thread.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_THREAD_HPP +#define BOOST_DETAIL_WIN_THREAD_HPP + +#include <boost/detail/win/basic_types.hpp> +#include <boost/detail/win/GetCurrentThread.hpp> + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::GetCurrentThreadId; + using ::SleepEx; + using ::Sleep; +#else +extern "C" { +# ifndef UNDER_CE + __declspec(dllimport) unsigned long __stdcall + GetCurrentThreadId(void); + __declspec(dllimport) unsigned long __stdcall + SleepEx(unsigned long,int); + __declspec(dllimport) void __stdcall + Sleep(unsigned long); +#else + using ::GetCurrentThreadId; + using ::SleepEx; + using ::Sleep; +#endif +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_THREAD_HPP diff --git a/boost/detail/win/time.hpp b/boost/detail/win/time.hpp new file mode 100644 index 0000000000..7f636edbae --- /dev/null +++ b/boost/detail/win/time.hpp @@ -0,0 +1,72 @@ +// time.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_TIME_HPP +#define BOOST_DETAIL_WIN_TIME_HPP + +#include <boost/detail/win/basic_types.hpp> + + +namespace boost { +namespace detail { +namespace win32 { +#if defined( BOOST_USE_WINDOWS_H ) + typedef FILETIME FILETIME_; + typedef PFILETIME PFILETIME_; + typedef LPFILETIME LPFILETIME_; + + typedef SYSTEMTIME SYSTEMTIME_; + typedef SYSTEMTIME* PSYSTEMTIME_; + + #ifndef UNDER_CE // Windows CE does not define GetSystemTimeAsFileTime + using ::GetSystemTimeAsFileTime; + #endif + using ::FileTimeToLocalFileTime; + using ::GetSystemTime; + using ::SystemTimeToFileTime; + using ::GetTickCount; + +#else +extern "C" { + typedef struct _FILETIME { + DWORD_ dwLowDateTime; + DWORD_ dwHighDateTime; + } FILETIME_, *PFILETIME_, *LPFILETIME_; + + typedef struct _SYSTEMTIME { + WORD_ wYear; + WORD_ wMonth; + WORD_ wDayOfWeek; + WORD_ wDay; + WORD_ wHour; + WORD_ wMinute; + WORD_ wSecond; + WORD_ wMilliseconds; + } SYSTEMTIME_, *PSYSTEMTIME_; + + #ifndef UNDER_CE // Windows CE does not define GetSystemTimeAsFileTime + __declspec(dllimport) void WINAPI + GetSystemTimeAsFileTime(FILETIME_* lpFileTime); + #endif + __declspec(dllimport) int WINAPI + FileTimeToLocalFileTime(const FILETIME_* lpFileTime, + FILETIME_* lpLocalFileTime); + __declspec(dllimport) void WINAPI + GetSystemTime(SYSTEMTIME_* lpSystemTime); + __declspec(dllimport) int WINAPI + SystemTimeToFileTime(const SYSTEMTIME_* lpSystemTime, + FILETIME_* lpFileTime); + __declspec(dllimport) unsigned long __stdcall + GetTickCount(); +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_TIME_HPP diff --git a/boost/detail/win/timers.hpp b/boost/detail/win/timers.hpp new file mode 100644 index 0000000000..753c91f83e --- /dev/null +++ b/boost/detail/win/timers.hpp @@ -0,0 +1,41 @@ +// timers.hpp --------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WIN_TIMERS_HPP +#define BOOST_DETAIL_WIN_TIMERS_HPP + +#include <boost/detail/win/basic_types.hpp> + + +namespace boost +{ +namespace detail +{ +namespace win32 +{ +#if defined( BOOST_USE_WINDOWS_H ) + using ::QueryPerformanceCounter; + using ::QueryPerformanceFrequency; +#else +extern "C" { + __declspec(dllimport) BOOL_ WINAPI + QueryPerformanceCounter( + LARGE_INTEGER_ *lpPerformanceCount + ); + + __declspec(dllimport) BOOL_ WINAPI + QueryPerformanceFrequency( + LARGE_INTEGER_ *lpFrequency + ); +} +#endif +} +} +} + +#endif // BOOST_DETAIL_WIN_TIMERS_HPP diff --git a/boost/detail/workaround.hpp b/boost/detail/workaround.hpp new file mode 100644 index 0000000000..40b3423b37 --- /dev/null +++ b/boost/detail/workaround.hpp @@ -0,0 +1,267 @@ +// Copyright David Abrahams 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef WORKAROUND_DWA2002126_HPP +# define WORKAROUND_DWA2002126_HPP + +// Compiler/library version workaround macro +// +// Usage: +// +// #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +// // workaround for eVC4 and VC6 +// ... // workaround code here +// #endif +// +// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the +// first argument must be undefined or expand to a numeric +// value. The above expands to: +// +// (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300 +// +// When used for workarounds that apply to the latest known version +// and all earlier versions of a compiler, the following convention +// should be observed: +// +// #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301)) +// +// The version number in this case corresponds to the last version in +// which the workaround was known to have been required. When +// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro +// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates +// the workaround for any version of the compiler. When +// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or +// error will be issued if the compiler version exceeds the argument +// to BOOST_TESTED_AT(). This can be used to locate workarounds which +// may be obsoleted by newer versions. + +# ifndef BOOST_STRICT_CONFIG + +#include <boost/config.hpp> + +#ifndef __BORLANDC__ +#define __BORLANDC___WORKAROUND_GUARD 1 +#else +#define __BORLANDC___WORKAROUND_GUARD 0 +#endif +#ifndef __CODEGEARC__ +#define __CODEGEARC___WORKAROUND_GUARD 1 +#else +#define __CODEGEARC___WORKAROUND_GUARD 0 +#endif +#ifndef _MSC_VER +#define _MSC_VER_WORKAROUND_GUARD 1 +#else +#define _MSC_VER_WORKAROUND_GUARD 0 +#endif +#ifndef _MSC_FULL_VER +#define _MSC_FULL_VER_WORKAROUND_GUARD 1 +#else +#define _MSC_FULL_VER_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_MSVC +#define BOOST_MSVC_WORKAROUND_GUARD 1 +#else +#define BOOST_MSVC_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_MSVC_FULL_VER +#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1 +#else +#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0 +#endif +#ifndef __GNUC__ +#define __GNUC___WORKAROUND_GUARD 1 +#else +#define __GNUC___WORKAROUND_GUARD 0 +#endif +#ifndef __GNUC_MINOR__ +#define __GNUC_MINOR___WORKAROUND_GUARD 1 +#else +#define __GNUC_MINOR___WORKAROUND_GUARD 0 +#endif +#ifndef __GNUC_PATCHLEVEL__ +#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1 +#else +#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0 +#endif +#ifndef __IBMCPP__ +#define __IBMCPP___WORKAROUND_GUARD 1 +#else +#define __IBMCPP___WORKAROUND_GUARD 0 +#endif +#ifndef __SUNPRO_CC +#define __SUNPRO_CC_WORKAROUND_GUARD 1 +#else +#define __SUNPRO_CC_WORKAROUND_GUARD 0 +#endif +#ifndef __DECCXX_VER +#define __DECCXX_VER_WORKAROUND_GUARD 1 +#else +#define __DECCXX_VER_WORKAROUND_GUARD 0 +#endif +#ifndef __MWERKS__ +#define __MWERKS___WORKAROUND_GUARD 1 +#else +#define __MWERKS___WORKAROUND_GUARD 0 +#endif +#ifndef __EDG__ +#define __EDG___WORKAROUND_GUARD 1 +#else +#define __EDG___WORKAROUND_GUARD 0 +#endif +#ifndef __EDG_VERSION__ +#define __EDG_VERSION___WORKAROUND_GUARD 1 +#else +#define __EDG_VERSION___WORKAROUND_GUARD 0 +#endif +#ifndef __HP_aCC +#define __HP_aCC_WORKAROUND_GUARD 1 +#else +#define __HP_aCC_WORKAROUND_GUARD 0 +#endif +#ifndef __hpxstd98 +#define __hpxstd98_WORKAROUND_GUARD 1 +#else +#define __hpxstd98_WORKAROUND_GUARD 0 +#endif +#ifndef _CRAYC +#define _CRAYC_WORKAROUND_GUARD 1 +#else +#define _CRAYC_WORKAROUND_GUARD 0 +#endif +#ifndef __DMC__ +#define __DMC___WORKAROUND_GUARD 1 +#else +#define __DMC___WORKAROUND_GUARD 0 +#endif +#ifndef MPW_CPLUS +#define MPW_CPLUS_WORKAROUND_GUARD 1 +#else +#define MPW_CPLUS_WORKAROUND_GUARD 0 +#endif +#ifndef __COMO__ +#define __COMO___WORKAROUND_GUARD 1 +#else +#define __COMO___WORKAROUND_GUARD 0 +#endif +#ifndef __COMO_VERSION__ +#define __COMO_VERSION___WORKAROUND_GUARD 1 +#else +#define __COMO_VERSION___WORKAROUND_GUARD 0 +#endif +#ifndef __INTEL_COMPILER +#define __INTEL_COMPILER_WORKAROUND_GUARD 1 +#else +#define __INTEL_COMPILER_WORKAROUND_GUARD 0 +#endif +#ifndef __ICL +#define __ICL_WORKAROUND_GUARD 1 +#else +#define __ICL_WORKAROUND_GUARD 0 +#endif +#ifndef _COMPILER_VERSION +#define _COMPILER_VERSION_WORKAROUND_GUARD 1 +#else +#define _COMPILER_VERSION_WORKAROUND_GUARD 0 +#endif + +#ifndef _RWSTD_VER +#define _RWSTD_VER_WORKAROUND_GUARD 1 +#else +#define _RWSTD_VER_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_RWSTD_VER +#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1 +#else +#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0 +#endif +#ifndef __GLIBCPP__ +#define __GLIBCPP___WORKAROUND_GUARD 1 +#else +#define __GLIBCPP___WORKAROUND_GUARD 0 +#endif +#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC +#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1 +#else +#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0 +#endif +#ifndef __SGI_STL_PORT +#define __SGI_STL_PORT_WORKAROUND_GUARD 1 +#else +#define __SGI_STL_PORT_WORKAROUND_GUARD 0 +#endif +#ifndef _STLPORT_VERSION +#define _STLPORT_VERSION_WORKAROUND_GUARD 1 +#else +#define _STLPORT_VERSION_WORKAROUND_GUARD 0 +#endif +#ifndef __LIBCOMO_VERSION__ +#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1 +#else +#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0 +#endif +#ifndef _CPPLIB_VER +#define _CPPLIB_VER_WORKAROUND_GUARD 1 +#else +#define _CPPLIB_VER_WORKAROUND_GUARD 0 +#endif + +#ifndef BOOST_INTEL_CXX_VERSION +#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1 +#else +#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_INTEL_WIN +#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1 +#else +#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_DINKUMWARE_STDLIB +#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1 +#else +#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_INTEL +#define BOOST_INTEL_WORKAROUND_GUARD 1 +#else +#define BOOST_INTEL_WORKAROUND_GUARD 0 +#endif +// Always define to zero, if it's used it'll be defined my MPL: +#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0 + +# define BOOST_WORKAROUND(symbol, test) \ + ((symbol ## _WORKAROUND_GUARD + 0 == 0) && \ + (symbol != 0) && (1 % (( (symbol test) ) + 1))) +// ^ ^ ^ ^ +// The extra level of parenthesis nesting above, along with the +// BOOST_OPEN_PAREN indirection below, is required to satisfy the +// broken preprocessor in MWCW 8.3 and earlier. +// +// The basic mechanism works as follows: +// (symbol test) + 1 => if (symbol test) then 2 else 1 +// 1 % ((symbol test) + 1) => if (symbol test) then 1 else 0 +// +// The complication with % is for cooperation with BOOST_TESTED_AT(). +// When "test" is BOOST_TESTED_AT(x) and +// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined, +// +// symbol test => if (symbol <= x) then 1 else -1 +// (symbol test) + 1 => if (symbol <= x) then 2 else 0 +// 1 % ((symbol test) + 1) => if (symbol <= x) then 1 else divide-by-zero +// + +# ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS +# define BOOST_OPEN_PAREN ( +# define BOOST_TESTED_AT(value) > value) ?(-1): BOOST_OPEN_PAREN 1 +# else +# define BOOST_TESTED_AT(value) != ((value)-(value)) +# endif + +# else + +# define BOOST_WORKAROUND(symbol, test) 0 + +# endif + +#endif // WORKAROUND_DWA2002126_HPP |