Commits

Anonymous committed 615e8ba

Add boost 1.45.0 as a subrepos.

Comments (0)

Files changed (1147)

 build/general = http://hg.sim.no/GeneralMSVCGeneration/default
+include/boost = http://hg.sim.no/boost-header-libs/full
 d12bf6cbb77c33f3023eae9dc8ae08c782eb862f build/general
-8b95c17d0bdf9dc29ae4328ef3e0eaf6bab4d934 src/extensions/superglu
+c08b0fe9cfa458e0510df2154105dcc570df50ce include/boost

include/boost/aligned_storage.hpp

-//-----------------------------------------------------------------------------
-// boost aligned_storage.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2002-2003
-// Eric Friedman, Itay Maman
-//
-// 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_ALIGNED_STORAGE_HPP
-#define BOOST_ALIGNED_STORAGE_HPP
-
-#include <cstddef> // for std::size_t
-
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
-#include "boost/type_traits/alignment_of.hpp"
-#include "boost/type_traits/type_with_alignment.hpp"
-#include "boost/type_traits/is_pod.hpp"
-
-#include "boost/mpl/eval_if.hpp"
-#include "boost/mpl/identity.hpp"
-
-#include "boost/type_traits/detail/bool_trait_def.hpp"
-
-namespace boost {
-
-namespace detail { namespace aligned_storage {
-
-BOOST_STATIC_CONSTANT(
-      std::size_t
-    , alignment_of_max_align = ::boost::alignment_of<max_align>::value
-    );
-
-//
-// To be TR1 conforming this must be a POD type:
-//
-template <
-      std::size_t size_
-    , std::size_t alignment_
->
-struct aligned_storage_imp
-{
-    union data_t
-    {
-        char buf[size_];
-
-        typename mpl::eval_if_c<
-              alignment_ == std::size_t(-1)
-            , mpl::identity<detail::max_align>
-            , type_with_alignment<alignment_>
-            >::type align_;
-    } data_;
-};
-
-}} // namespace detail::aligned_storage
-
-template <
-      std::size_t size_
-    , std::size_t alignment_ = std::size_t(-1)
->
-class aligned_storage
-{
-private: // representation
-
-   detail::aligned_storage::aligned_storage_imp<size_, alignment_> data_;
-
-public: // constants
-
-    typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
-
-    BOOST_STATIC_CONSTANT(
-          std::size_t
-        , size = size_
-        );
-    BOOST_STATIC_CONSTANT(
-          std::size_t
-        , alignment = (
-              alignment_ == std::size_t(-1)
-            ? ::boost::detail::aligned_storage::alignment_of_max_align
-            : alignment_
-            )
-        );
-
-#if defined(__GNUC__) &&\
-    (__GNUC__ >  3) ||\
-    (__GNUC__ == 3 && (__GNUC_MINOR__ >  2 ||\
-                      (__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >=3)))
-
-private: // noncopyable
-
-    aligned_storage(const aligned_storage&);
-    aligned_storage& operator=(const aligned_storage&);
-
-#else // gcc less than 3.2.3
-
-public: // _should_ be noncopyable, but GCC compiler emits error
-
-    aligned_storage(const aligned_storage&);
-    aligned_storage& operator=(const aligned_storage&);
-
-#endif // gcc < 3.2.3 workaround
-
-public: // structors
-
-    aligned_storage()
-    {
-    }
-
-    ~aligned_storage()
-    {
-    }
-
-public: // accessors
-
-    void* address()
-    {
-        return this;
-    }
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
-    const void* address() const
-    {
-        return this;
-    }
-
-#else // MSVC6
-
-    const void* address() const;
-
-#endif // MSVC6 workaround
-
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
-// MSVC6 seems not to like inline functions with const void* returns, so we
-// declare the following here:
-
-template <std::size_t S, std::size_t A>
-const void* aligned_storage<S,A>::address() const
-{
-    return const_cast< aligned_storage<S,A>* >(this)->address();
-}
-
-#endif // MSVC6 workaround
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// Make sure that is_pod recognises aligned_storage<>::type
-// as a POD (Note that aligned_storage<> itself is not a POD):
-//
-template <std::size_t size_, std::size_t alignment_>
-struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
-   BOOST_TT_AUX_BOOL_C_BASE(true)
-{ 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true)
-}; 
-#endif
-
-
-} // namespace boost
-
-#include "boost/type_traits/detail/bool_trait_undef.hpp"
-
-#endif // BOOST_ALIGNED_STORAGE_HPP

include/boost/assert.hpp

-//
-//  boost/assert.hpp - BOOST_ASSERT(expr)
-//
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 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)
-//
-//  Note: There are no include guards. This is intentional.
-//
-//  See http://www.boost.org/libs/utility/assert.html for documentation.
-//
-
-#undef BOOST_ASSERT
-
-#if defined(BOOST_DISABLE_ASSERTS)
-
-# define BOOST_ASSERT(expr) ((void)0)
-
-#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
-
-#include <boost/current_function.hpp>
-
-namespace boost
-{
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
-
-} // namespace boost
-
-#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
-
-#else
-# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
-# define BOOST_ASSERT(expr) assert(expr)
-#endif
-
-#undef BOOST_VERIFY
-
-#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
-
-# define BOOST_VERIFY(expr) ((void)(expr))
-
-#else
-
-# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
-
-#endif

include/boost/bind.hpp

-#ifndef BOOST_BIND_HPP_INCLUDED
-#define BOOST_BIND_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  bind.hpp - binds function objects to arguments
-//
-//  Copyright (c) 2009 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-#include <boost/bind/bind.hpp>
-
-#endif // #ifndef BOOST_BIND_HPP_INCLUDED

include/boost/bind/arg.hpp

-#ifndef BOOST_BIND_ARG_HPP_INCLUDED
-#define BOOST_BIND_ARG_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  bind/arg.hpp
-//
-//  Copyright (c) 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)
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-#include <boost/config.hpp>
-#include <boost/is_placeholder.hpp>
-
-namespace boost
-{
-
-template< int I > struct arg
-{
-    arg()
-    {
-    }
-
-    template< class T > arg( T const & /* t */ )
-    {
-        // static assert I == is_placeholder<T>::value
-        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
-    }
-};
-
-template< int I > bool operator==( arg<I> const &, arg<I> const & )
-{
-    return true;
-}
-
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
-template< int I > struct is_placeholder< arg<I> >
-{
-    enum _vt { value = I };
-};
-
-template< int I > struct is_placeholder< arg<I> (*) () >
-{
-    enum _vt { value = I };
-};
-
-#endif
-
-} // namespace boost
-
-#endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED

include/boost/bind/bind.hpp

-#ifndef BOOST_BIND_BIND_HPP_INCLUDED
-#define BOOST_BIND_BIND_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  bind.hpp - binds function objects to arguments
-//
-//  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2001 David Abrahams
-//  Copyright (c) 2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//  See http://www.boost.org/libs/bind/bind.html for documentation.
-//
-
-#include <boost/config.hpp>
-#include <boost/ref.hpp>
-#include <boost/mem_fn.hpp>
-#include <boost/type.hpp>
-#include <boost/is_placeholder.hpp>
-#include <boost/bind/arg.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/visit_each.hpp>
-
-// Borland-specific bug, visit_each() silently fails to produce code
-
-#if defined(__BORLANDC__)
-#  define BOOST_BIND_VISIT_EACH boost::visit_each
-#else
-#  define BOOST_BIND_VISIT_EACH visit_each
-#endif
-
-#include <boost/bind/storage.hpp>
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4512) // assignment operator could not be generated
-#endif
-
-namespace boost
-{
-
-template<class T> class weak_ptr;
-
-namespace _bi // implementation details
-{
-
-// result_traits
-
-template<class R, class F> struct result_traits
-{
-    typedef R type;
-};
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-struct unspecified {};
-
-template<class F> struct result_traits<unspecified, F>
-{
-    typedef typename F::result_type type;
-};
-
-template<class F> struct result_traits< unspecified, reference_wrapper<F> >
-{
-    typedef typename F::result_type type;
-};
-
-#endif
-
-// ref_compare
-
-template<class T> bool ref_compare( T const & a, T const & b, long )
-{
-    return a == b;
-}
-
-template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
-{
-    return true;
-}
-
-template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
-{
-    return true;
-}
-
-template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
-{
-    return a.get_pointer() == b.get_pointer();
-}
-
-// bind_t forward declaration for listN
-
-template<class R, class F, class L> class bind_t;
-
-template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
-{
-    return a.compare( b );
-}
-
-// value
-
-template<class T> class value
-{
-public:
-
-    value(T const & t): t_(t) {}
-
-    T & get() { return t_; }
-    T const & get() const { return t_; }
-
-    bool operator==(value const & rhs) const
-    {
-        return t_ == rhs.t_;
-    }
-
-private:
-
-    T t_;
-};
-
-// ref_compare for weak_ptr
-
-template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
-{
-    return !(a.get() < b.get()) && !(b.get() < a.get());
-}
-
-// type
-
-template<class T> class type {};
-
-// unwrap
-
-template<class F> struct unwrapper
-{
-    static inline F & unwrap( F & f, long )
-    {
-        return f;
-    }
-
-    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
-    {
-        return rf.get();
-    }
-
-    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
-    {
-        return _mfi::dm<R, T>( pm );
-    }
-};
-
-// listN
-
-class list0
-{
-public:
-
-    list0() {}
-
-    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
-    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
-    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
-    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
-    {
-        return unwrapper<F>::unwrap(f, 0)();
-    }
-
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
-    {
-        return unwrapper<F const>::unwrap(f, 0)();
-    }
-
-    template<class F, class A> void operator()(type<void>, F & f, A &, int)
-    {
-        unwrapper<F>::unwrap(f, 0)();
-    }
-
-    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
-    {
-        unwrapper<F const>::unwrap(f, 0)();
-    }
-
-    template<class V> void accept(V &) const
-    {
-    }
-
-    bool operator==(list0 const &) const
-    {
-        return true;
-    }
-};
-
-template< class A1 > class list1: private storage1< A1 >
-{
-private:
-
-    typedef storage1< A1 > base_type;
-
-public:
-
-    explicit list1( A1 a1 ): base_type( a1 ) {}
-
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-
-    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
-
-    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
-
-    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
-    {
-        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
-    }
-
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
-    {
-        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
-    }
-
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
-    {
-        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
-    }
-
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
-    {
-        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
-    }
-
-    template<class V> void accept(V & v) const
-    {
-        base_type::accept(v);
-    }
-
-    bool operator==(list1 const & rhs) const
-    {
-        return ref_compare(base_type::a1_, rhs.a1_, 0);
-    }
-};
-
-struct logical_and;
-struct logical_or;
-
-template< class A1, class A2 > class list2: private storage2< A1, A2 >
-{
-private:
-
-    typedef storage2< A1, A2 > base_type;
-
-public:
-
-    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
-
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-
-    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
-
-    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
-
-    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
-
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
-    {
-        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
-    }
-
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
-    {
-        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
-    }
-
-    template<class F, class A> void operator()(type<void>, F & f,