]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Add a directory that we apparently need.
authorbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 2 Jun 2011 13:57:20 +0000 (13:57 +0000)
committerbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 2 Jun 2011 13:57:20 +0000 (13:57 +0000)
git-svn-id: https://svn.dealii.org/trunk@23760 0785d39b-7218-0410-832d-ea1e28bc413d

32 files changed:
deal.II/contrib/boost-1.46.1/include/boost/variant/apply_visitor.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/bad_visit.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_binary.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_delayed.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_unary.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/backup_holder.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/bool_trait_def.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/bool_trait_undef.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/cast_storage.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/config.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/enable_recursive.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/enable_recursive_fwd.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/forced_return.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/generic_result_type.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/has_nothrow_move.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/has_trivial_move.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/initializer.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/make_variant_list.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/move.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/over_sequence.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/substitute.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/substitute_fwd.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/variant_io.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/detail/visitation_impl.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/get.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_variant.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_wrapper.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_wrapper_fwd.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/static_visitor.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/variant.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/variant_fwd.hpp [new file with mode: 0644]
deal.II/contrib/boost-1.46.1/include/boost/variant/visitor_ptr.hpp [new file with mode: 0644]

diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/apply_visitor.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/apply_visitor.hpp
new file mode 100644 (file)
index 0000000..53bada0
--- /dev/null
@@ -0,0 +1,20 @@
+//-----------------------------------------------------------------------------
+// boost variant/apply_visitor.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_VARIANT_APPLY_VISITOR_HPP
+#define BOOST_VARIANT_APPLY_VISITOR_HPP
+
+#include "boost/variant/detail/apply_visitor_unary.hpp"
+#include "boost/variant/detail/apply_visitor_binary.hpp"
+#include "boost/variant/detail/apply_visitor_delayed.hpp"
+
+#endif // BOOST_VARIANT_APPLY_VISITOR_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/bad_visit.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/bad_visit.hpp
new file mode 100644 (file)
index 0000000..ca53940
--- /dev/null
@@ -0,0 +1,41 @@
+//-----------------------------------------------------------------------------
+// boost variant/bad_visit.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-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_VARIANT_BAD_VISIT_HPP
+#define BOOST_VARIANT_BAD_VISIT_HPP
+
+#include <exception>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class bad_visit
+//
+// Exception thrown when a visitation attempt via apply_visitor fails due
+// to invalid visited subtype or contents.
+//
+struct bad_visit
+    : std::exception
+{
+public: // std::exception interface
+
+    virtual const char * what() const throw()
+    {
+        return "boost::bad_visit: "
+               "failed visitation using boost::apply_visitor";
+    }
+
+};
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_BAD_VISIT_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_binary.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_binary.hpp
new file mode 100644 (file)
index 0000000..f1c1fb6
--- /dev/null
@@ -0,0 +1,182 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_binary.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-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_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
+
+#include "boost/variant/detail/apply_visitor_unary.hpp"
+
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+#include "boost/utility/enable_if.hpp"
+#include "boost/mpl/not.hpp"
+#include "boost/type_traits/is_const.hpp"
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable1, visitable2)
+//
+// Visits visitable1 and visitable2 such that their values (which we
+// shall call x and y, respectively) are used as arguments in the
+// expression visitor(x, y).
+//
+
+namespace detail { namespace variant {
+
+template <typename Visitor, typename Value1>
+class apply_visitor_binary_invoke
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+    Value1& value1_;
+
+public: // structors
+
+    apply_visitor_binary_invoke(Visitor& visitor, Value1& value1)
+        : visitor_(visitor)
+        , value1_(value1)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value2>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Value2& value2)
+    {
+        return visitor_(value1_, value2);
+    }
+
+private:
+    apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
+
+};
+
+template <typename Visitor, typename Visitable2>
+class apply_visitor_binary_unwrap
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+    Visitable2& visitable2_;
+
+public: // structors
+
+    apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2)
+        : visitor_(visitor)
+        , visitable2_(visitable2)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value1>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Value1& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+private:
+    apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&);
+
+};
+
+}} // namespace detail::variant
+
+//
+// nonconst-visitor version:
+//
+
+#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+    /**/
+
+#else // EDG-based compilers
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    typename enable_if< \
+          mpl::not_< is_const< V > > \
+        , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+        >::type \
+    /**/
+
+#endif // EDG-based compilers workaround
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(
+      Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+#undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
+
+//
+// const-visitor version:
+//
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+          typename Visitor::result_type
+        )
+apply_visitor(
+      const Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          const Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+#endif // MSVC7 and below exclusion
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_delayed.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_delayed.hpp
new file mode 100644 (file)
index 0000000..2650508
--- /dev/null
@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_delayed.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-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_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
+
+#include "boost/variant/detail/generic_result_type.hpp"
+
+#include "boost/variant/detail/apply_visitor_unary.hpp"
+#include "boost/variant/detail/apply_visitor_binary.hpp"
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor)
+//
+// Returns a function object, overloaded for unary and binary usage, that
+// visits its arguments using visitor (or a copy of visitor) via
+//  * apply_visitor( visitor, [argument] )
+// under unary invocation, or
+//  * apply_visitor( visitor, [argument1], [argument2] )
+// under binary invocation.
+//
+// NOTE: Unlike other apply_visitor forms, the visitor object must be
+//   non-const; this prevents user from giving temporary, to disastrous
+//   effect (i.e., returned function object would have dead reference).
+//
+
+template <typename Visitor>
+class apply_visitor_delayed_t
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+
+public: // structors
+
+    explicit apply_visitor_delayed_t(Visitor& visitor)
+      : visitor_(visitor)
+    {
+    }
+
+public: // unary visitor interface
+
+    template <typename Visitable>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitable& visitable)
+    {
+        return apply_visitor(visitor_, visitable);
+    }
+
+public: // binary visitor interface
+
+    template <typename Visitable1, typename Visitable2>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitable1& visitable1, Visitable2& visitable2)
+    {
+        return apply_visitor(visitor_, visitable1, visitable2);
+    }
+
+private:
+    apply_visitor_delayed_t& operator=(const apply_visitor_delayed_t&);
+
+};
+
+template <typename Visitor>
+inline apply_visitor_delayed_t<Visitor> apply_visitor(Visitor& visitor)
+{
+    return apply_visitor_delayed_t<Visitor>(visitor);
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_unary.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/apply_visitor_unary.hpp
new file mode 100644 (file)
index 0000000..64199d8
--- /dev/null
@@ -0,0 +1,83 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_unary.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-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_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
+
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+#include "boost/utility/enable_if.hpp"
+#include "boost/mpl/not.hpp"
+#include "boost/type_traits/is_const.hpp"
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable)
+//
+// Visits visitable with visitor.
+//
+
+//
+// nonconst-visitor version:
+//
+
+#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+    /**/
+
+#else // EDG-based compilers
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    typename enable_if< \
+          mpl::not_< is_const< V > > \
+        , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+        >::type \
+    /**/
+
+#endif // EDG-based compilers workaround
+
+template <typename Visitor, typename Visitable>
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+
+#undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
+
+//
+// const-visitor version:
+//
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+template <typename Visitor, typename Visitable>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+apply_visitor(const Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+
+#endif // MSVC7 and below exclusion
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/backup_holder.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/backup_holder.hpp
new file mode 100644 (file)
index 0000000..ed112b8
--- /dev/null
@@ -0,0 +1,94 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/backup_holder.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_VARIANT_DETAIL_BACKUP_HOLDER_HPP
+#define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
+
+#include "boost/assert.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+template <typename T>
+class backup_holder
+{
+private: // representation
+
+    T* backup_;
+
+public: // structors
+
+    ~backup_holder()
+    {
+        delete backup_;
+    }
+
+    explicit backup_holder(T* backup)
+        : backup_(backup)
+    {
+    }
+
+    backup_holder(const backup_holder&);
+
+public: // modifiers
+
+    backup_holder& operator=(const backup_holder& rhs)
+    {
+        *backup_ = rhs.get();
+        return *this;
+    }
+
+    backup_holder& operator=(const T& rhs)
+    {
+        *backup_ = rhs;
+        return *this;
+    }
+
+    void swap(backup_holder& rhs)
+    {
+        T* tmp = rhs.backup_;
+        rhs.backup_ = this->backup_;
+        this->backup_ = tmp;
+    }
+
+public: // queries
+
+    T& get()
+    {
+        return *backup_;
+    }
+
+    const T& get() const
+    {
+        return *backup_;
+    }
+
+};
+
+template <typename T>
+backup_holder<T>::backup_holder(const backup_holder&)
+    : backup_(0)
+{
+    // not intended for copy, but do not want to prohibit syntactically
+    BOOST_ASSERT(false);
+}
+
+template <typename T>
+void swap(backup_holder<T>& lhs, backup_holder<T>& rhs)
+{
+    lhs.swap(rhs);
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/bool_trait_def.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/bool_trait_def.hpp
new file mode 100644 (file)
index 0000000..823a79a
--- /dev/null
@@ -0,0 +1,30 @@
+//-----------------------------------------------------------------------------
+// boost/variant/detail/bool_trait_def.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)
+
+// Needed until move-related traits incorporated into type_traits library.
+// no include guards, the header is intended for multiple inclusion!
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_def.hpp"
+
+#define BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \
+template< typename T > struct trait \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+/**/
+
+#define BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(arity, name) \
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(arity, name) \
+/**/
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/bool_trait_undef.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/bool_trait_undef.hpp
new file mode 100644 (file)
index 0000000..9b8fb54
--- /dev/null
@@ -0,0 +1,21 @@
+//-----------------------------------------------------------------------------
+// boost/variant/detail/bool_trait_undef.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)
+
+// Needed until move-related traits incorporated into type_traits library.
+// no include guards, the header is intended for multiple inclusion!
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
+
+#undef BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1
+#undef BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/cast_storage.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/cast_storage.hpp
new file mode 100644 (file)
index 0000000..f23f174
--- /dev/null
@@ -0,0 +1,48 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/cast_storage.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_VARIANT_DETAIL_CAST_STORAGE_HPP
+#define BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
+
+#include "boost/config.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template cast_storage
+//
+// Casts the given storage to the specified type, but with qualification.
+//
+
+template <typename T>
+inline T& cast_storage(
+      void* storage
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)
+    )
+{
+    return *static_cast<T*>(storage);
+}
+
+template <typename T>
+inline const T& cast_storage(
+      const void* storage
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)
+    )
+{
+    return *static_cast<const T*>(storage);
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/config.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/config.hpp
new file mode 100644 (file)
index 0000000..eb18201
--- /dev/null
@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/config.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_VARIANT_DETAIL_CONFIG_HPP
+#define BOOST_VARIANT_DETAIL_CONFIG_HPP
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING
+//
+#if BOOST_WORKAROUND(__MWERKS__, <= 0x3201) \
+ || BOOST_WORKAROUND(BOOST_INTEL, <= 700) \
+ || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ && !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING)
+#   define BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND
+//
+#if !defined(BOOST_NO_SFINAE) \
+ && !BOOST_WORKAROUND(BOOST_INTEL, <= 700) \
+ && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
+#   define BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND
+#endif
+
+#endif // BOOST_VARIANT_DETAIL_CONFIG_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/enable_recursive.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/enable_recursive.hpp
new file mode 100644 (file)
index 0000000..76bd7c7
--- /dev/null
@@ -0,0 +1,162 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/enable_recursive.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_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
+#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
+
+#include "boost/variant/detail/enable_recursive_fwd.hpp"
+#include "boost/variant/variant_fwd.hpp"
+
+#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+#   include "boost/mpl/apply.hpp"
+#   include "boost/mpl/eval_if.hpp"
+#   include "boost/mpl/lambda.hpp"
+#endif
+
+#include "boost/variant/detail/substitute.hpp"
+#include "boost/mpl/aux_/config/ctps.hpp"
+#include "boost/mpl/bool_fwd.hpp"
+#include "boost/mpl/if.hpp"
+#include "boost/mpl/or.hpp"
+#include "boost/type_traits/is_pointer.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/type_traits/is_same.hpp"
+
+#include "boost/variant/recursive_wrapper.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    substitute< T , Dest , Source > \
+    /**/
+
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template rebind1
+//
+// Limited workaround in case 'substitute' metafunction unavailable.
+//
+
+template <typename T, typename U1>
+struct rebind1
+{
+private:
+    typedef typename mpl::lambda<
+          mpl::identity<T>
+        >::type le_;
+
+public:
+    typedef typename mpl::eval_if<
+          is_same< le_, mpl::identity<T> >
+        , le_ // identity<T>
+        , mpl::apply1<le_, U1>
+        >::type type;
+};
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    rebind1< T , Dest > \
+    /**/
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction enable_recursive
+//
+// See boost/variant/detail/enable_recursive_fwd.hpp for more information.
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T, typename RecursiveVariant, typename NoWrapper>
+struct enable_recursive
+    : BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )
+{
+};
+
+template <typename T, typename RecursiveVariant>
+struct enable_recursive< T,RecursiveVariant,mpl::false_ >
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )::type t_;
+
+public: // metafunction result
+
+    // [Wrap with recursive_wrapper only if rebind really changed something:]
+    typedef typename mpl::if_<
+          mpl::or_<
+              is_same< t_,T >
+            , is_reference<t_>
+            , is_pointer<t_>
+            >
+        , t_
+        , boost::recursive_wrapper<t_>
+        >::type type;
+
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T, typename RecursiveVariant, typename NoWrapper>
+struct enable_recursive
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )::type t_;
+
+public: // metafunction result
+
+    // [Wrap with recursive_wrapper only if rebind really changed something:]
+    typedef typename mpl::if_<
+          mpl::or_<
+              NoWrapper
+            , is_same< t_,T >
+            , is_reference<t_>
+            , is_pointer<t_>
+            >
+        , t_
+        , boost::recursive_wrapper<t_>
+        >::type type;
+
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction class quoted_enable_recursive
+//
+// Same behavior as enable_recursive metafunction (see above).
+//
+template <typename RecursiveVariant, typename NoWrapper>
+struct quoted_enable_recursive
+{
+    template <typename T>
+    struct apply
+        : enable_recursive<T, RecursiveVariant, NoWrapper>
+    {
+    };
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/enable_recursive_fwd.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/enable_recursive_fwd.hpp
new file mode 100644 (file)
index 0000000..3336c1f
--- /dev/null
@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/enable_recursive_fwd.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_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
+#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
+
+#include "boost/mpl/aux_/config/ctps.hpp"
+
+#include "boost/mpl/bool_fwd.hpp"
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include "boost/mpl/bool.hpp"
+#else
+#   include "boost/type_traits/is_base_and_derived.hpp"
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) tag recursive_flag
+//
+// Signifies that the variant should perform recursive substituion.
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct recursive_flag
+{
+    typedef T type;
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+struct recursive_flag_tag
+{
+};
+
+template <typename T>
+struct recursive_flag
+    : recursive_flag_tag
+{
+    typedef T type;
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_recursive_flag
+//
+// Signifies that the variant should perform recursive substituion.
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct is_recursive_flag
+    : mpl::false_
+{
+};
+
+template <typename T>
+struct is_recursive_flag< recursive_flag<T> >
+    : mpl::true_
+{
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct is_recursive_flag
+    : is_base_and_derived< recursive_flag_tag,T >
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction enable_recursive
+//
+// Attempts recursive_variant_ tag substitution, wrapping with
+// boost::recursive_wrapper if substituion occurs w/ non-indirect result
+// (i.e., not a reference or pointer) *and* NoWrapper is false_.
+//
+template <
+      typename T
+    , typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct enable_recursive;
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction class quoted_enable_recursive
+//
+// Same behavior as enable_recursive metafunction (see above).
+//
+template <
+      typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct quoted_enable_recursive;
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/forced_return.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/forced_return.hpp
new file mode 100644 (file)
index 0000000..cc1f25b
--- /dev/null
@@ -0,0 +1,104 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/forced_return.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_VARIANT_DETAIL_FORCED_RETURN_HPP
+#define BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
+
+#include "boost/config.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
+#include "boost/assert.hpp"
+
+#if !defined(BOOST_MSVC) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include "boost/type_traits/remove_reference.hpp"
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template forced_return
+//
+// Logical error to permit invocation at runtime, but (artificially) satisfies
+// compile-time requirement of returning a result value.
+//
+
+#if !defined(BOOST_MSVC)                                \
+ && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)  \
+ && !defined(BOOST_NO_VOID_RETURNS)
+
+// "standard" implementation:
+
+template <typename T>
+inline T forced_return( BOOST_EXPLICIT_TEMPLATE_TYPE(T) )
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    typedef typename boost::remove_reference<T>::type basic_type;
+    basic_type* dummy = 0;
+    return *static_cast< basic_type* >(dummy);
+}
+
+template <>
+inline void forced_return<void>( BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(void) )
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+}
+
+#elif !defined(BOOST_MSVC)
+
+// workaround implementation
+//
+// TODO: Determine the most efficient way to handle this -- as below? by
+// throwing? by recursive call to forced_return itself? etc.
+//
+
+template <typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
+forced_return( BOOST_EXPLICIT_TEMPLATE_TYPE(T) )
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) (*dummy)() = 0;
+    return dummy();
+}
+
+#else // defined(BOOST_MSVC)
+
+// msvc-specific implementation
+//
+// Leverages __declspec(noreturn) for optimized implementation.
+//
+
+__declspec(noreturn)
+inline void forced_return_no_return() {};
+
+template <typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
+forced_return( BOOST_EXPLICIT_TEMPLATE_TYPE(T) )
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    forced_return_no_return();
+}
+
+#endif // BOOST_MSVC optimization
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/generic_result_type.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/generic_result_type.hpp
new file mode 100644 (file)
index 0000000..b3fbb19
--- /dev/null
@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/generic_result_type.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_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
+#define BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
+
+#include "boost/config.hpp"
+
+//////////////////////////////////////////////////////////////////////////
+// (workaround) macro BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE
+//
+// On compilers with BOOST_NO_VOID_RETURNS, this macro provides a route
+// to a single syntax for dealing with template functions that may (but
+// not necessarily) return nothing (i.e. void).
+//
+// BOOST_VARIANT_AUX_RETURN_VOID provided for compilers w/ (erroneous?)
+// warnings about non-void functions not returning a value.
+//
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \
+    T   \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID  \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE \
+    void    \
+    /**/
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+namespace boost {
+namespace detail { namespace variant {
+
+struct fake_return_void
+{
+    fake_return_void()
+    {
+    }
+
+    template <typename T>
+    fake_return_void(const T&)
+    {
+    }
+};
+
+template <typename T>
+struct no_void_returns_helper
+{
+    typedef T type;
+};
+
+template <>
+struct no_void_returns_helper<void>
+{
+    typedef fake_return_void type;
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \
+    BOOST_DEDUCED_TYPENAME                                           \
+        ::boost::detail::variant::no_void_returns_helper< T >::type  \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID  \
+    return ::boost::detail::variant::fake_return_void()     \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE  \
+    ::boost::detail::variant::fake_return_void
+
+#endif // BOOST_NO_VOID_RETURNS workaround
+
+#endif // BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/has_nothrow_move.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/has_nothrow_move.hpp
new file mode 100644 (file)
index 0000000..51ca095
--- /dev/null
@@ -0,0 +1,106 @@
+
+// (C) Copyright Eric Friedman 2002-2003.
+// 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.
+
+#ifndef BOOST_VARIANT_DETAIL_HAS_NOTHROW_MOVE_HPP_INCLUDED
+#define BOOST_VARIANT_DETAIL_HAS_NOTHROW_MOVE_HPP_INCLUDED
+
+#include "boost/config.hpp" // for STATIC_CONSTANT
+#include "boost/variant/detail/has_trivial_move.hpp"
+#include "boost/type_traits/has_nothrow_copy.hpp"
+#include "boost/type_traits/has_nothrow_assign.hpp"
+
+#include "boost/mpl/and.hpp"
+#include "boost/mpl/or.hpp"
+
+// should be the last #include
+#include "boost/variant/detail/bool_trait_def.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+// TRAIT: has_nothrow_move
+
+template <typename T>
+struct has_nothrow_move_impl
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::mpl::or_<
+                has_trivial_move<T>
+              , ::boost::mpl::and_<
+                  has_nothrow_copy<T>
+                , has_nothrow_assign<T>
+                >
+            >::type::value
+            )
+        );
+};
+
+BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(
+      has_nothrow_move
+    , T
+    , (::boost::detail::variant::has_nothrow_move_impl<T>::value)
+    )
+
+
+// TRAIT: has_nothrow_move_constructor
+
+template <typename T>
+struct has_nothrow_move_constructor_impl
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::mpl::or_<
+              has_nothrow_move<T>
+            , has_trivial_move_constructor<T>
+            , has_nothrow_copy<T>
+            >::type::value
+            )
+        );
+};
+
+BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(
+      has_nothrow_move_constructor
+    , T
+    , (::boost::detail::variant::has_nothrow_move_constructor_impl<T>::value)
+    )
+
+
+// TRAIT: has_nothrow_move_assign
+
+template <typename T>
+struct has_nothrow_move_assign_impl
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::mpl::or_<
+              has_nothrow_move<T>
+            , has_trivial_move_assign<T>
+            , has_nothrow_assign<T>
+            >::type::value
+            )
+        );
+};
+
+BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(
+      has_nothrow_move_assign
+    , T
+    , (::boost::detail::variant::has_nothrow_move_assign_impl<T>::value)
+    )
+
+}} // namespace detail::variant
+
+BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_nothrow_move)
+BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_nothrow_move_constructor)
+BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_nothrow_move_assign)
+
+} // namespace boost
+
+#include "boost/variant/detail/bool_trait_undef.hpp"
+
+#endif // BOOST_VARIANT_DETAIL_HAS_NOTHROW_MOVE_HPP_INCLUDED
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/has_trivial_move.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/has_trivial_move.hpp
new file mode 100644 (file)
index 0000000..5293366
--- /dev/null
@@ -0,0 +1,100 @@
+
+// (C) Copyright Eric Friedman 2002-2003.
+// 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.
+
+#ifndef BOOST_VARIANT_DETAIL_HAS_TRIVIAL_MOVE_HPP_INCLUDED
+#define BOOST_VARIANT_DETAIL_HAS_TRIVIAL_MOVE_HPP_INCLUDED
+
+#include "boost/config.hpp" // for STATIC_CONSTANT
+#include "boost/type_traits/has_trivial_copy.hpp"
+#include "boost/type_traits/has_trivial_assign.hpp"
+
+#include "boost/mpl/and.hpp"
+#include "boost/mpl/or.hpp"
+
+// should be the last #include
+#include "boost/variant/detail/bool_trait_def.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+// TRAIT: has_trivial_move
+
+template <typename T>
+struct has_trivial_move_impl
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::mpl::and_<
+              has_trivial_copy<T>
+            , has_trivial_assign<T>
+            >::type::value
+            )
+        );
+};
+
+BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(
+      has_trivial_move
+    , T
+    , (::boost::detail::variant::has_trivial_move_impl<T>::value)
+    )
+
+
+// TRAIT: has_trivial_move_constructor
+
+template <typename T>
+struct has_trivial_move_constructor_impl
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::mpl::or_<
+              has_trivial_move<T>
+            , has_trivial_copy<T>
+            >::type::value
+            )
+        );
+};
+
+BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(
+      has_trivial_move_constructor
+    , T
+    , (::boost::detail::variant::has_trivial_move_constructor_impl<T>::value)
+    )
+
+
+// TRAIT: has_trivial_move_assign
+
+template <typename T>
+struct has_trivial_move_assign_impl
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::mpl::or_<
+              has_trivial_move<T>
+            , has_trivial_assign<T>
+            >::type::value
+            )
+        );
+};
+
+BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(
+      has_trivial_move_assign
+    , T
+    , (::boost::detail::variant::has_trivial_move_assign_impl<T>::value)
+    )
+
+}} // namespace detail::variant
+
+BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_trivial_move)
+BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_trivial_move_constructor)
+BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_trivial_move_assign)
+
+} // namespace boost
+
+#include "boost/variant/detail/bool_trait_undef.hpp"
+
+#endif // BOOST_VARIANT_DETAIL_HAS_TRIVIAL_MOVE_HPP_INCLUDED
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/initializer.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/initializer.hpp
new file mode 100644 (file)
index 0000000..b14d6c8
--- /dev/null
@@ -0,0 +1,265 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/initializer.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_VARIANT_DETAIL_INITIALIZER_HPP
+#define BOOST_VARIANT_DETAIL_INITIALIZER_HPP
+
+#include <new> // for placement new
+
+#include "boost/config.hpp"
+
+#include "boost/call_traits.hpp"
+#include "boost/detail/reference_content.hpp"
+#include "boost/variant/recursive_wrapper_fwd.hpp"
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   include "boost/mpl/aux_/value_wknd.hpp"
+#   include "boost/mpl/int.hpp"
+#   include "boost/mpl/iter_fold.hpp"
+#   include "boost/mpl/next.hpp"
+#   include "boost/mpl/deref.hpp"
+#   include "boost/mpl/pair.hpp"
+#   include "boost/mpl/protect.hpp"
+#else
+#   include "boost/variant/variant_fwd.hpp"
+#   include "boost/preprocessor/cat.hpp"
+#   include "boost/preprocessor/enum.hpp"
+#   include "boost/preprocessor/repeat.hpp"
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) support to simulate standard overload resolution rules
+//
+// The below initializers allows variant to follow standard overload
+// resolution rules over the specified set of bounded types.
+//
+// On compilers where using declarations in class templates can correctly
+// avoid name hiding, use an optimal solution based on the variant's typelist.
+//
+// Otherwise, use a preprocessor workaround based on knowledge of the fixed
+// size of the variant's psuedo-variadic template parameter list.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+// (detail) quoted metafunction make_initializer_node
+//
+// Exposes a pair whose first type is a node in the initializer hierarchy.
+//
+struct make_initializer_node
+{
+    template <typename BaseIndexPair, typename Iterator>
+    struct apply
+    {
+    private: // helpers, for metafunction result (below)
+
+        typedef typename BaseIndexPair::first
+            base;
+        typedef typename BaseIndexPair::second
+            index;
+
+        class initializer_node
+            : public base
+        {
+        private: // helpers, for static functions (below)
+
+            typedef typename mpl::deref<Iterator>::type
+                recursive_enabled_T;
+            typedef typename unwrap_recursive<recursive_enabled_T>::type
+                public_T;
+            typedef typename call_traits<public_T>::param_type
+                param_T;
+
+        public: // static functions
+
+            using base::initialize;
+
+            static int initialize(void* dest, param_T operand)
+            {
+                typedef typename boost::detail::make_reference_content<
+                      recursive_enabled_T
+                    >::type internal_T;
+
+                new(dest) internal_T(operand);
+                return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
+            }
+
+        };
+
+        friend class initializer_node;
+
+    public: // metafunction result
+
+        typedef mpl::pair<
+              initializer_node
+            , typename mpl::next< index >::type
+            > type;
+
+    };
+};
+
+// (detail) class initializer_root
+//
+// Every level of the initializer hierarchy must expose the name
+// "initialize," so initializer_root provides a dummy function:
+//
+class initializer_root
+{
+public: // static functions
+
+    static void initialize();
+
+};
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+    /**/
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+    /**/
+
+#   else // MSVC7 and below
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+        , BOOST_VARIANT_ENUM_PARAMS(typename param_T) \
+    /**/
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+    /**/
+
+#   endif // MSVC7 and below workaround
+
+template < BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS >
+struct preprocessor_list_initializer
+{
+public: // static functions
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \
+        BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+        static int initialize( \
+              void* dest \
+            , BOOST_PP_CAT(param_T,N) operand \
+            ) \
+        { \
+            typedef typename boost::detail::make_reference_content< \
+                  BOOST_PP_CAT(recursive_enabled_T,N) \
+                >::type internal_T; \
+            \
+            new(dest) internal_T(operand); \
+            return (N); /*which*/ \
+        } \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+
+};
+
+#   if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+
+#if !defined(BOOST_VARIANT_AUX_ECHO)
+#   define BOOST_VARIANT_AUX_ECHO(z,N,token) token
+#endif
+
+template <>
+struct preprocessor_list_initializer<
+      BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, int)
+    , BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, const int)
+    >
+{
+};
+
+#   endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_INITIALIZER_T
+//
+// Given both the variant's typelist and a basename for forming the list of
+// bounded types (i.e., T becomes T1, T2, etc.), exposes the initializer
+// most appropriate to the current compiler.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::mpl::iter_fold< \
+          mpl_seq \
+        , ::boost::mpl::pair< \
+              ::boost::detail::variant::initializer_root \
+            , ::boost::mpl::int_<0> \
+            > \
+        , ::boost::mpl::protect< \
+              ::boost::detail::variant::make_initializer_node \
+            > \
+        >::type::first \
+    /**/
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        /**/
+
+#   else // MSVC7 and below
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE(z,N,T) \
+        ::boost::call_traits< \
+              ::boost::unwrap_recursive<BOOST_PP_CAT(T,N)>::type \
+            >::param_type \
+        /**/
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        , BOOST_PP_ENUM( \
+              BOOST_VARIANT_LIMIT_TYPES \
+            , BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE \
+            , typename_base \
+            ) \
+        /**/
+
+#   endif // MSVC7 workaround
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::detail::variant::preprocessor_list_initializer< \
+          BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+        > \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/make_variant_list.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/make_variant_list.hpp
new file mode 100644 (file)
index 0000000..b2c74ad
--- /dev/null
@@ -0,0 +1,60 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/make_variant_list.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_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
+#define BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
+
+#include "boost/variant/variant_fwd.hpp"
+
+#include "boost/mpl/list.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/enum.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction make_variant_list
+//
+// Provides a MPL-compatible sequence with the specified non-void types
+// as arguments.
+//
+// Rationale: see class template convert_void (variant_fwd.hpp) and using-
+// declaration workaround (below).
+//
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+struct make_variant_list
+{
+public: // metafunction result
+
+    // [Define a macro to convert any void(NN) tags to mpl::void...]
+#   define BOOST_VARIANT_AUX_CONVERT_VOID(z, N,_)  \
+        typename convert_void< BOOST_PP_CAT(T,N) >::type
+
+    // [...so that the specified types can be passed to mpl::list...]
+    typedef typename mpl::list< 
+          BOOST_PP_ENUM(
+              BOOST_VARIANT_LIMIT_TYPES
+            , BOOST_VARIANT_AUX_CONVERT_VOID
+            , _
+            )
+        >::type type;
+
+    // [...and, finally, the conversion macro can be undefined:]
+#   undef BOOST_VARIANT_AUX_CONVERT_VOID
+
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/move.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/move.hpp
new file mode 100644 (file)
index 0000000..572cfbb
--- /dev/null
@@ -0,0 +1,166 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/move.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+//  Copyright (c) 2002-2003 Eric Friedman
+//  Copyright (c) 2002 by Andrei Alexandrescu
+//
+//  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)
+//
+//  This file derivative of MoJO. Much thanks to Andrei for his initial work.
+//  See <http://www.cuj.com/experts/2102/alexandr.htm> for information on MOJO.
+//  Re-issued here under the Boost Software License, with permission of the original
+//  author (Andrei Alexandrescu).
+
+
+#ifndef BOOST_VARIANT_DETAIL_MOVE_HPP
+#define BOOST_VARIANT_DETAIL_MOVE_HPP
+
+#include <iterator> // for iterator_traits
+#include <new> // for placement new
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/mpl/if.hpp"
+#include "boost/type_traits/is_base_and_derived.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+//////////////////////////////////////////////////////////////////////////
+// forward declares
+//
+// NOTE: Incomplete until (if?) Boost.Move becomes part of Boost.
+//
+template <typename Deriving> class moveable;
+template <typename T>        class move_source;
+template <typename T>        class move_return;
+
+namespace detail {
+
+// (detail) moveable_tag
+//
+// Concrete type from which moveable<T> derives.
+//
+// TODO: Move into moveable_fwd.hpp and define has_move_constructor.
+//
+template <typename Deriving>
+struct moveable_tag
+{
+};
+
+} // namespace detail
+
+//////////////////////////////////////////////////////////////////////////
+// function template move
+//
+// Takes a T& and returns, if T derives moveable<T>, a move_source<T> for
+// the object; else, returns the T&.
+//
+
+namespace detail {
+
+// (detail) class template move_type
+//
+// Metafunction that, given moveable T, provides move_source<T>, else T&.
+//
+template <typename T>
+struct move_type
+{
+public: // metafunction result
+
+    typedef typename mpl::if_<
+          is_base_and_derived<detail::moveable_tag<T>, T>
+        , move_source<T>
+        , T&
+        >::type type;
+
+};
+
+} // namespace detail
+
+template <typename T>
+inline
+    typename detail::move_type<T>::type
+move(T& source)
+{
+    typedef typename detail::move_type<T>::type
+        move_t;
+
+    return move_t(source);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// class template return_t
+//
+// Metafunction that, given moveable T, provides move_return<T>, else T.
+//
+template <typename T>
+struct return_t
+{
+public: // metafunction result
+
+    typedef typename mpl::if_<
+          is_base_and_derived<moveable<T>, T>
+        , move_return<T>
+        , T
+        >::type type;
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// function template move_swap
+//
+// Swaps using Koenig lookup but falls back to move-swap for primitive
+// types and on non-conforming compilers.
+//
+
+#if   defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)   \
+ ||   BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(2))
+
+// [Indicate that move_swap by overload is disabled...]
+#define BOOST_NO_MOVE_SWAP_BY_OVERLOAD
+
+// [...and provide straight swap-by-move implementation:]
+template <typename T>
+inline void move_swap(T& lhs, T& rhs)
+{
+    T tmp( boost::detail::variant::move(lhs) );
+    lhs = boost::detail::variant::move(rhs);
+    rhs = boost::detail::variant::move(tmp);
+}
+
+#else// !workaround
+
+namespace detail { namespace move_swap {
+
+template <typename T>
+inline void swap(T& lhs, T& rhs)
+{
+    T tmp( boost::detail::variant::move(lhs) );
+    lhs = boost::detail::variant::move(rhs);
+    rhs = boost::detail::variant::move(tmp);
+}
+
+}} // namespace detail::move_swap
+
+template <typename T>
+inline void move_swap(T& lhs, T& rhs)
+{
+    using detail::move_swap::swap;
+
+    swap(lhs, rhs);
+}
+
+#endif // workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MOVE_HPP
+
+
+
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/over_sequence.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/over_sequence.hpp
new file mode 100644 (file)
index 0000000..bdd69ad
--- /dev/null
@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/over_sequence.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// Portions Copyright (C) 2002 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)
+
+#ifndef BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
+#define BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
+
+#include "boost/mpl/aux_/config/ctps.hpp"
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include "boost/mpl/eval_if.hpp"
+#   include "boost/mpl/bool.hpp"
+#   include "boost/mpl/identity.hpp"
+#   include "boost/type.hpp"
+#endif
+
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class over_sequence
+//
+// Wrapper used to indicate bounded types for variant are from type sequence.
+//
+template <typename Types>
+struct over_sequence
+{
+    typedef Types type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_over_sequence (modeled on code by David Abrahams)
+//
+// Indicates whether the specified type is of form over_sequence<...> or not.
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct is_over_sequence
+    : mpl::false_
+{
+};
+
+template <typename Types>
+struct is_over_sequence< over_sequence<Types> >
+    : mpl::true_
+{
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+typedef char (&yes_over_sequence_t)[1];
+typedef char (&no_over_sequence_t)[2];
+
+no_over_sequence_t is_over_sequence_test(...);
+
+template<typename T>
+yes_over_sequence_t is_over_sequence_test(
+      type< ::boost::detail::variant::over_sequence<T> >
+    );
+
+template<typename T>
+struct is_over_sequence_impl
+{
+    BOOST_STATIC_CONSTANT(bool, value = (
+          sizeof(is_over_sequence_test(type<T>()))
+          == sizeof(yes_over_sequence_t)
+        ));
+};
+
+template <typename T>
+struct is_over_sequence
+    : mpl::bool_<
+          ::boost::detail::variant::is_over_sequence_impl<T>::value
+        >
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/substitute.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/substitute.hpp
new file mode 100644 (file)
index 0000000..97fe205
--- /dev/null
@@ -0,0 +1,231 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+//-----------------------------------------------------------------------------
+// boost variant/detail/substitute.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_VARIANT_DETAIL_SUBSTITUTE_HPP
+#define BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+#include "boost/mpl/aux_/config/ctps.hpp"
+
+#include "boost/variant/detail/substitute_fwd.hpp"
+#include "boost/mpl/aux_/lambda_arity_param.hpp"
+#include "boost/mpl/aux_/preprocessor/params.hpp"
+#include "boost/mpl/aux_/preprocessor/repeat.hpp"
+#include "boost/mpl/int_fwd.hpp"
+#include "boost/mpl/limits/arity.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/empty.hpp"
+#include "boost/preprocessor/arithmetic/inc.hpp"
+#include "boost/preprocessor/iterate.hpp"
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction substitute
+//
+// Substitutes one type for another in the given type expression.
+//
+
+//
+// primary template
+//
+template <
+      typename T, typename Dest, typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
+          typename Arity /* = ... (see substitute_fwd.hpp) */
+        )
+    >
+struct substitute
+{
+    typedef T type;
+};
+
+//
+// tag substitution specializations
+//
+
+#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(CV_) \
+    template <typename Dest, typename Source> \
+    struct substitute< \
+          CV_ Source \
+        , Dest \
+        , Source \
+          BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \
+        > \
+    { \
+        typedef CV_ Dest type; \
+    }; \
+    /**/
+
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG( BOOST_PP_EMPTY() )
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(volatile)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const volatile)
+
+#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG
+
+//
+// pointer specializations
+//
+#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(CV_) \
+    template <typename T, typename Dest, typename Source> \
+    struct substitute< \
+          T * CV_ \
+        , Dest \
+        , Source \
+          BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \
+        > \
+    { \
+        typedef typename substitute< \
+              T, Dest, Source \
+            >::type * CV_ type; \
+    }; \
+    /**/
+
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER( BOOST_PP_EMPTY() )
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(volatile)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const volatile)
+
+#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER
+
+//
+// reference specializations
+//
+template <typename T, typename Dest, typename Source>
+struct substitute<
+      T&
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+    typedef typename substitute<
+          T, Dest, Source
+        >::type & type;
+};
+
+//
+// template expression (i.e., F<...>) specializations
+//
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \
+    typedef typename substitute< \
+          BOOST_PP_CAT(U,N), Dest, Source \
+        >::type BOOST_PP_CAT(u,N); \
+    /**/
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF(z, N, _) \
+    BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL( BOOST_PP_INC(N) ) \
+    /**/
+
+#define BOOST_PP_ITERATION_LIMITS (0,BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
+#define BOOST_PP_FILENAME_1 "boost/variant/detail/substitute.hpp"
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+///// iteration, depth == 1
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+#define i BOOST_PP_FRAME_ITERATION(1)
+
+#if i > 0
+
+//
+// template specializations
+//
+template <
+      template < BOOST_MPL_PP_PARAMS(i,typename P) > class T
+    , BOOST_MPL_PP_PARAMS(i,typename U)
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< BOOST_MPL_PP_PARAMS(i,U) >
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<( i )>)
+    >
+{
+private:
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef T< BOOST_MPL_PP_PARAMS(i,u) > type;
+};
+
+//
+// function specializations
+//
+template <
+      typename R
+    , BOOST_MPL_PP_PARAMS(i,typename U)
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( BOOST_MPL_PP_PARAMS(i,U) )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef r (*type)( BOOST_MPL_PP_PARAMS(i,u) );
+};
+
+#elif i == 0
+
+//
+// zero-arg function specialization
+//
+template <
+      typename R, typename Dest, typename Source
+    >
+struct substitute<
+      R (*)( void )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+
+public:
+    typedef r (*type)( void );
+};
+
+#endif // i
+
+#undef i
+#endif // BOOST_PP_IS_ITERATING
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/substitute_fwd.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/substitute_fwd.hpp
new file mode 100644 (file)
index 0000000..1723847
--- /dev/null
@@ -0,0 +1,59 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/substitute_fwd.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_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
+#define BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
+
+#include "boost/mpl/aux_/lambda_arity_param.hpp"
+#include "boost/mpl/aux_/template_arity.hpp"
+#include "boost/mpl/int_fwd.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+//
+// Defined if 'substitute' is not implementable on the current compiler.
+//
+
+#include "boost/mpl/aux_/config/ctps.hpp"
+#include "boost/mpl/aux_/config/ttp.hpp"
+
+#if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+ || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ && !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+#   define BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction substitute
+//
+// Substitutes one type for another in the given type expression.
+//
+template <
+      typename T, typename Dest, typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
+          typename Arity = mpl::int_< mpl::aux::template_arity<T>::value >
+        )
+    >
+struct substitute;
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/variant_io.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/variant_io.hpp
new file mode 100644 (file)
index 0000000..192a3de
--- /dev/null
@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/variant_io.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_VARIANT_DETAIL_VARIANT_IO_HPP
+#define BOOST_VARIANT_DETAIL_VARIANT_IO_HPP
+
+#include <iosfwd> // for std::basic_ostream forward declare
+
+#include "boost/variant/variant_fwd.hpp"
+
+#include "boost/detail/templated_streams.hpp"
+#include "boost/variant/static_visitor.hpp"
+
+namespace boost {
+
+///////////////////////////////////////////////////////////////////////////////
+// function template operator<<
+//
+// Outputs the content of the given variant to the given ostream.
+//
+
+// forward declare (allows output of embedded variant< variant< ... >, ... >)
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
+    );
+
+namespace detail { namespace variant {
+
+template <typename OStream>
+class printer
+    : public boost::static_visitor<>
+{
+private: // representation
+
+    OStream& out_;
+
+public: // structors
+
+    explicit printer(OStream& out)
+        : out_( out )
+    {
+    }
+
+public: // visitor interface
+
+    template <typename T>
+    void operator()(const T& operand) const
+    {
+        out_ << operand;
+    }
+
+private:
+    printer& operator=(const printer&);
+
+};
+
+}} // namespace detail::variant
+
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
+    )
+{
+    detail::variant::printer<
+          BOOST_TEMPLATED_STREAM(ostream, E,T)
+        > visitor(out);
+
+    rhs.apply_visitor(visitor);
+
+    return out;
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_VARIANT_IO_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/visitation_impl.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/detail/visitation_impl.hpp
new file mode 100644 (file)
index 0000000..0d4271a
--- /dev/null
@@ -0,0 +1,294 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/visitation_impl.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_VARIANT_DETAIL_VISITATION_IMPL_HPP
+#define BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
+
+#include "boost/config.hpp"
+
+#include "boost/variant/detail/backup_holder.hpp"
+#include "boost/variant/detail/cast_storage.hpp"
+#include "boost/variant/detail/forced_return.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
+
+#include "boost/assert.hpp"
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/identity.hpp"
+#include "boost/mpl/int.hpp"
+#include "boost/mpl/next.hpp"
+#include "boost/mpl/deref.hpp"
+#include "boost/mpl/or.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/inc.hpp"
+#include "boost/preprocessor/repeat.hpp"
+#include "boost/type_traits/is_same.hpp"
+#include "boost/type_traits/has_nothrow_copy.hpp"
+#include "boost/variant/detail/has_nothrow_move.hpp"
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 
+# pragma warning (push) 
+# pragma warning (disable : 4702) //unreachable code 
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+//
+// Unrolls variant's visitation mechanism to reduce template instantiation
+// and potentially increase runtime performance. (TODO: Investigate further.)
+//
+#if !defined(BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+#   define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT   \
+        BOOST_VARIANT_LIMIT_TYPES
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class apply_visitor_unrolled
+//
+// Tag type indicates when visitation_impl is unrolled.
+//
+struct apply_visitor_unrolled {};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template visitation_impl_step
+//
+// "Never ending" iterator range facilitates visitation_impl unrolling.
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename Iter, typename LastIter>
+struct visitation_impl_step
+{
+    typedef typename mpl::deref<Iter>::type type;
+
+    typedef typename mpl::next<Iter>::type next_iter;
+    typedef visitation_impl_step<
+          next_iter, LastIter
+        > next;
+};
+
+template <typename LastIter>
+struct visitation_impl_step< LastIter,LastIter >
+{
+    typedef apply_visitor_unrolled type;
+    typedef visitation_impl_step next;
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename Iter, typename LastIter>
+struct visitation_impl_step
+{
+    typedef typename mpl::eval_if<
+          is_same<Iter, LastIter>
+        , mpl::identity<apply_visitor_unrolled>
+        , Iter
+        >::type type;
+
+    typedef typename mpl::eval_if<
+          is_same<type, apply_visitor_unrolled> //is_same<Iter, LastIter>
+        , mpl::identity<LastIter>
+        , mpl::next<Iter>
+        >::type next_iter;
+
+    typedef visitation_impl_step<
+          next_iter, LastIter
+        > next;
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template visitation_impl_invoke
+//
+// Invokes the given visitor on the specified type in the given storage.
+//
+
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke_impl(
+      int, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::true_// never_uses_backup
+    )
+{
+    return visitor.internal_visit(
+          cast_storage<T>(storage), 1L
+        );
+}
+
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke_impl(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::false_// never_uses_backup
+    )
+{
+    if (internal_which >= 0)
+    {
+        return visitor.internal_visit(
+              cast_storage<T>(storage), 1L
+            );
+    }
+    else
+    {
+        return visitor.internal_visit(
+              cast_storage< backup_holder<T> >(storage), 1L
+            );
+    }
+}
+
+template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
+    , NoBackupFlag
+    , int
+    )
+{
+    typedef typename mpl::or_<
+          NoBackupFlag
+        , has_nothrow_move_constructor<T>
+        , has_nothrow_copy<T>
+        >::type never_uses_backup;
+
+    return visitation_impl_invoke_impl(
+          internal_which, visitor, storage, t
+        , never_uses_backup()
+        );
+}
+
+template <typename Visitor, typename VoidPtrCV, typename NBF>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
+{
+    // should never be here at runtime:
+    BOOST_ASSERT(false);
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template visitation_impl
+//
+// Invokes the given visitor on the type in the given variant storage.
+//
+
+template <
+      typename W, typename S
+    , typename Visitor, typename VPCV
+    , typename NBF
+    >
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl(
+      int, int, Visitor&, VPCV
+    , mpl::true_ // is_apply_visitor_unrolled
+    , NBF, W* = 0, S* = 0
+    )
+{
+    // should never be here at runtime:
+    BOOST_ASSERT(false);
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+
+template <
+      typename Which, typename step0
+    , typename Visitor, typename VoidPtrCV
+    , typename NoBackupFlag
+    >
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl(
+      const int internal_which, const int logical_which
+    , Visitor& visitor, VoidPtrCV storage
+    , mpl::false_ // is_apply_visitor_unrolled
+    , NoBackupFlag no_backup_flag
+    , Which* = 0, step0* = 0
+    )
+{
+    // Typedef apply_visitor_unrolled steps and associated types...
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF(z, N, _) \
+    typedef typename BOOST_PP_CAT(step,N)::type BOOST_PP_CAT(T,N); \
+    typedef typename BOOST_PP_CAT(step,N)::next \
+        BOOST_PP_CAT(step, BOOST_PP_INC(N)); \
+    /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF
+        , _
+        )
+
+#   undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF
+
+    // ...switch on the target which-index value...
+    switch (logical_which)
+    {
+
+    // ...applying the appropriate case:
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE(z, N, _) \
+    case (Which::value + (N)): \
+        return visitation_impl_invoke( \
+              internal_which, visitor, storage \
+            , static_cast<BOOST_PP_CAT(T,N)*>(0) \
+            , no_backup_flag, 1L \
+            ); \
+    /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
+        , _
+        )
+
+#   undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
+
+    }
+
+    // If not handled in this iteration, continue unrolling:
+    typedef mpl::int_<
+          Which::value + (BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+        > next_which;
+
+    typedef BOOST_PP_CAT(step, BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+        next_step;
+
+    typedef typename next_step::type next_type;
+    typedef typename is_same< next_type,apply_visitor_unrolled >::type
+        is_apply_visitor_unrolled;
+
+    return visitation_impl(
+          internal_which, logical_which
+        , visitor, storage
+        , is_apply_visitor_unrolled()
+        , no_backup_flag
+        , static_cast<next_which*>(0), static_cast<next_step*>(0)
+        );
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
+# pragma warning(pop)  
+#endif 
+
+#endif // BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/get.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/get.hpp
new file mode 100644 (file)
index 0000000..99a65f6
--- /dev/null
@@ -0,0 +1,202 @@
+//-----------------------------------------------------------------------------
+// boost variant/get.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 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_VARIANT_GET_HPP
+#define BOOST_VARIANT_GET_HPP
+
+#include <exception>
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/utility/addressof.hpp"
+#include "boost/variant/variant_fwd.hpp"
+
+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/add_pointer.hpp"
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#   include "boost/mpl/bool.hpp"
+#   include "boost/mpl/or.hpp"
+#   include "boost/type_traits/is_same.hpp"
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class bad_get
+//
+// The exception thrown in the event of a failed get of a value.
+//
+class bad_get
+    : public std::exception
+{
+public: // std::exception implementation
+
+    virtual const char * what() const throw()
+    {
+        return "boost::bad_get: "
+               "failed value get using boost::get";
+    }
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// function template get<T>
+//
+// Retrieves content of given variant object if content is of type T.
+// Otherwise: pointer ver. returns 0; reference ver. throws bad_get.
+//
+
+namespace detail { namespace variant {
+
+// (detail) class template get_visitor
+//
+// Generic static visitor that: if the value is of the specified type,
+// returns a pointer to the value it visits; else a null pointer.
+//
+template <typename T>
+struct get_visitor
+{
+private: // private typedefs
+
+    typedef typename add_pointer<T>::type pointer;
+    typedef typename add_reference<T>::type reference;
+
+public: // visitor typedefs
+
+    typedef pointer result_type;
+
+public: // visitor interfaces
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+    pointer operator()(reference operand) const
+    {
+        return boost::addressof(operand);
+    }
+
+    template <typename U>
+    pointer operator()(const U&) const
+    {
+        return static_cast<pointer>(0);
+    }
+
+#else // MSVC6
+
+private: // helpers, for visitor interfaces (below)
+
+    pointer execute_impl(reference operand, mpl::true_) const
+    {
+        return boost::addressof(operand);
+    }
+
+    template <typename U>
+    pointer execute_impl(const U& operand, mpl::false_) const
+    {
+        return static_cast<pointer>(0);
+    }
+
+public: // visitor interfaces
+
+    template <typename U>
+    pointer operator()(U& operand) const
+    {
+        // MSVC6 finds normal implementation (above) ambiguous,
+        // so we must explicitly disambiguate
+
+        typedef typename mpl::or_<
+              is_same<U, T>
+            , is_same<const U, T>
+            >::type U_is_T;
+
+        return execute_impl(operand, U_is_T());
+    }
+
+#endif // MSVC6 workaround
+
+};
+
+}} // namespace detail::variant
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+#   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+    BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
+#else
+#   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+    , t* = 0
+#endif
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_visitor<U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_visitor<const U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = get<U>(&operand);
+
+    if (!result)
+        throw bad_get();
+    return *result;
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    U_ptr result = get<const U>(&operand);
+
+    if (!result)
+        throw bad_get();
+    return *result;
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_GET_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_variant.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_variant.hpp
new file mode 100644 (file)
index 0000000..c4cd3b0
--- /dev/null
@@ -0,0 +1,182 @@
+//-----------------------------------------------------------------------------
+// boost variant/recursive_variant.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_VARIANT_RECURSIVE_VARIANT_HPP
+#define BOOST_VARIANT_RECURSIVE_VARIANT_HPP
+
+#include "boost/variant/variant_fwd.hpp"
+#include "boost/variant/detail/enable_recursive.hpp"
+#include "boost/variant/detail/substitute_fwd.hpp"
+#include "boost/variant/detail/make_variant_list.hpp"
+#include "boost/variant/detail/over_sequence.hpp"
+
+#include "boost/mpl/aux_/lambda_arity_param.hpp"
+
+#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+#   include "boost/mpl/eval_if.hpp"
+#   include "boost/mpl/identity.hpp"
+#   include "boost/mpl/protect.hpp"
+#   include "boost/mpl/transform.hpp"
+#else
+#   include "boost/preprocessor/cat.hpp"
+#   include "boost/preprocessor/repeat.hpp"
+#endif
+
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/is_sequence.hpp"
+#include "boost/variant/variant.hpp"
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction specialization substitute
+//
+// Handles embedded variant types when substituting for recursive_variant_.
+//
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+template <
+      BOOST_VARIANT_ENUM_PARAMS(typename T)
+    , typename RecursiveVariant
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      ::boost::variant<
+          recursive_flag< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+    typedef ::boost::variant<
+          recursive_flag< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        > type;
+};
+
+template <
+      BOOST_VARIANT_ENUM_PARAMS(typename T)
+    , typename RecursiveVariant
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+
+#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::eval_if<
+          ::boost::detail::variant::is_over_sequence<T0>
+        , mpl::identity< T0 >
+        , make_variant_list< BOOST_VARIANT_ENUM_PARAMS(T) >
+        >::type initial_types;
+
+    typedef typename mpl::transform<
+          initial_types
+        , mpl::protect< quoted_enable_recursive<RecursiveVariant,mpl::true_> >
+        >::type types;
+
+public: // metafunction result
+
+    typedef ::boost::variant< types > type;
+
+#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+private: // helpers, for metafunction result (below)
+
+    #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_)  \
+        typedef typename enable_recursive<   \
+              BOOST_PP_CAT(T,N)              \
+            , RecursiveVariant               \
+            , mpl::true_                     \
+            >::type BOOST_PP_CAT(wknd_T,N);  \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+
+public: // metafunction result
+
+    typedef ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(wknd_T) > type;
+
+#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround
+
+};
+
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+//
+// no specializations: embedded variants unsupported on these compilers!
+//
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+struct make_recursive_variant
+{
+public: // metafunction result
+
+    typedef boost::variant<
+          detail::variant::recursive_flag< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        > type;
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant_over
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template <typename Types>
+struct make_recursive_variant_over
+{
+private: // precondition assertions
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value ));
+#endif
+
+public: // metafunction result
+
+    typedef typename make_recursive_variant<
+          detail::variant::over_sequence< Types >
+        >::type type;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_RECURSIVE_VARIANT_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_wrapper.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_wrapper.hpp
new file mode 100644 (file)
index 0000000..ddc7002
--- /dev/null
@@ -0,0 +1,123 @@
+//-----------------------------------------------------------------------------
+// boost variant/recursive_wrapper.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_VARIANT_RECURSIVE_WRAPPER_HPP
+#define BOOST_VARIANT_RECURSIVE_WRAPPER_HPP
+
+#include "boost/variant/recursive_wrapper_fwd.hpp"
+#include "boost/checked_delete.hpp"
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class template recursive_wrapper
+//
+// See docs and recursive_wrapper_fwd.hpp for more information.
+//
+
+template <typename T>
+class recursive_wrapper
+{
+public: // typedefs
+
+    typedef T type;
+
+private: // representation
+
+    T* p_;
+
+public: // structors
+
+    ~recursive_wrapper();
+    recursive_wrapper();
+
+    recursive_wrapper(const recursive_wrapper& operand);
+    recursive_wrapper(const T& operand);
+
+private: // helpers, for modifiers (below)
+
+    void assign(const T& rhs);
+
+public: // modifiers
+
+    recursive_wrapper& operator=(const recursive_wrapper& rhs)
+    {
+        assign( rhs.get() );
+        return *this;
+    }
+
+    recursive_wrapper& operator=(const T& rhs)
+    {
+        assign( rhs );
+        return *this;
+    }
+
+    void swap(recursive_wrapper& operand)
+    {
+        T* temp = operand.p_;
+        operand.p_ = p_;
+        p_ = temp;
+    }
+
+public: // queries
+
+    T& get() { return *get_pointer(); }
+    const T& get() const { return *get_pointer(); }
+
+    T* get_pointer() { return p_; }
+    const T* get_pointer() const { return p_; }
+
+};
+
+template <typename T>
+recursive_wrapper<T>::~recursive_wrapper()
+{
+    boost::checked_delete(p_);
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper()
+    : p_(new T)
+{
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(const recursive_wrapper& operand)
+    : p_(new T( operand.get() ))
+{
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(const T& operand)
+    : p_(new T(operand))
+{
+}
+
+template <typename T>
+void recursive_wrapper<T>::assign(const T& rhs)
+{
+    this->get() = rhs;
+}
+
+// function template swap
+//
+// Swaps two recursive_wrapper<T> objects of the same type T.
+//
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs)
+{
+    lhs.swap(rhs);
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_RECURSIVE_WRAPPER_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_wrapper_fwd.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/recursive_wrapper_fwd.hpp
new file mode 100644 (file)
index 0000000..69a0ec7
--- /dev/null
@@ -0,0 +1,147 @@
+//-----------------------------------------------------------------------------
+// boost variant/recursive_wrapper_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002
+// Eric Friedman, Itay Maman
+//
+// Portions Copyright (C) 2002 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)
+
+#ifndef BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
+#define BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
+
+#include "boost/mpl/aux_/config/ctps.hpp"
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include "boost/mpl/eval_if.hpp"
+#   include "boost/mpl/bool.hpp"
+#   include "boost/mpl/identity.hpp"
+#   include "boost/type.hpp"
+#endif
+
+#include "boost/mpl/aux_/lambda_support.hpp"
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_def.hpp"
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class template recursive_wrapper
+//
+// Enables recursive types in templates by breaking cyclic dependencies.
+//
+// For example:
+//
+//   class my;
+//
+//   typedef variant< int, recursive_wrapper<my> > var;
+//
+//   class my {
+//     var var_;
+//     ...
+//   };
+//
+template <typename T> class recursive_wrapper;
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction is_recursive_wrapper (modeled on code by David Abrahams)
+//
+// True iff specified type matches recursive_wrapper<T>.
+//
+
+namespace detail {
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct is_recursive_wrapper_impl
+    : mpl::false_
+{
+};
+
+template <typename T>
+struct is_recursive_wrapper_impl< recursive_wrapper<T> >
+    : mpl::true_
+{
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+typedef char (&yes_recursive_wrapper_t)[1];
+typedef char (&no_recursive_wrapper_t)[2];
+
+no_recursive_wrapper_t is_recursive_wrapper_test(...);
+
+template<typename T>
+yes_recursive_wrapper_t is_recursive_wrapper_test(
+      type< ::boost::recursive_wrapper<T> >
+    );
+
+template<typename T>
+struct is_recursive_wrapper_impl
+{
+    BOOST_STATIC_CONSTANT(bool, value = (
+          sizeof(is_recursive_wrapper_test(type<T>()))
+          == sizeof(yes_recursive_wrapper_t)
+        ));
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+      is_recursive_wrapper
+    , T
+    , (::boost::detail::is_recursive_wrapper_impl<T>::value)
+    )
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction unwrap_recursive
+//
+// If specified type T matches recursive_wrapper<U>, then U; else T.
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct unwrap_recursive
+{
+    typedef T type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T))
+};
+
+template <typename T>
+struct unwrap_recursive< recursive_wrapper<T> >
+{
+    typedef T type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,unwrap_recursive,(T))
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct unwrap_recursive
+    : mpl::eval_if<
+          is_recursive_wrapper<T>
+        , T
+        , mpl::identity< T >
+        >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T))
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+} // namespace boost
+
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
+#endif // BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/static_visitor.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/static_visitor.hpp
new file mode 100644 (file)
index 0000000..b59b6f5
--- /dev/null
@@ -0,0 +1,97 @@
+//-----------------------------------------------------------------------------
+// boost variant/static_visitor.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-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_VARIANT_STATIC_VISITOR_HPP
+#define BOOST_VARIANT_STATIC_VISITOR_HPP
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+
+#include "boost/mpl/if.hpp"
+#include "boost/type_traits/is_base_and_derived.hpp"
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#   include "boost/type_traits/is_same.hpp"
+#endif
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_def.hpp"
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class template static_visitor
+//
+// An empty base class that typedefs the return type of a deriving static
+// visitor. The class is analogous to std::unary_function in this role.
+//
+
+namespace detail {
+
+    struct is_static_visitor_tag { };
+
+    typedef void static_visitor_default_return;
+
+} // namespace detail
+
+template <typename R = ::boost::detail::static_visitor_default_return>
+class static_visitor
+    : public detail::is_static_visitor_tag
+{
+public: // typedefs
+
+    typedef R result_type;
+
+protected: // for use as base class only
+
+    static_visitor() { }
+    ~static_visitor() { }
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// metafunction is_static_visitor
+//
+// Value metafunction indicates whether the specified type derives from
+// static_visitor<...>.
+//
+// NOTE #1: This metafunction does NOT check whether the specified type
+//  fulfills the requirements of the StaticVisitor concept.
+//
+// NOTE #2: This template never needs to be specialized!
+//
+
+namespace detail {
+
+template <typename T>
+struct is_static_visitor_impl
+{
+    BOOST_STATIC_CONSTANT(bool, value = 
+        (::boost::is_base_and_derived< 
+            detail::is_static_visitor_tag,
+            T
+        >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+      is_static_visitor
+    , T
+    , (::boost::detail::is_static_visitor_impl<T>::value)
+    )
+
+} // namespace boost
+
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
+#endif // BOOST_VARIANT_STATIC_VISITOR_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/variant.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/variant.hpp
new file mode 100644 (file)
index 0000000..205ad8d
--- /dev/null
@@ -0,0 +1,1869 @@
+//-----------------------------------------------------------------------------
+// boost variant/variant.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_VARIANT_VARIANT_HPP
+#define BOOST_VARIANT_VARIANT_HPP
+
+#include <cstddef> // for std::size_t
+#include <new> // for placement new
+
+#if !defined(BOOST_NO_TYPEID)
+#include <typeinfo> // for typeid, std::type_info
+#endif // BOOST_NO_TYPEID
+
+#include "boost/variant/detail/config.hpp"
+#include "boost/mpl/aux_/config/eti.hpp"
+#include "boost/mpl/aux_/value_wknd.hpp"
+
+#include "boost/variant/variant_fwd.hpp"
+#include "boost/variant/detail/backup_holder.hpp"
+#include "boost/variant/detail/enable_recursive_fwd.hpp"
+#include "boost/variant/detail/forced_return.hpp"
+#include "boost/variant/detail/initializer.hpp"
+#include "boost/variant/detail/make_variant_list.hpp"
+#include "boost/variant/detail/over_sequence.hpp"
+#include "boost/variant/detail/visitation_impl.hpp"
+
+#include "boost/variant/detail/generic_result_type.hpp"
+#include "boost/variant/detail/has_nothrow_move.hpp"
+#include "boost/variant/detail/move.hpp"
+
+#include "boost/detail/reference_content.hpp"
+#include "boost/aligned_storage.hpp"
+#include "boost/blank.hpp"
+#include "boost/static_assert.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/repeat.hpp"
+#include "boost/type_traits/alignment_of.hpp"
+#include "boost/type_traits/add_const.hpp"
+#include "boost/type_traits/has_nothrow_constructor.hpp"
+#include "boost/type_traits/has_nothrow_copy.hpp"
+#include "boost/type_traits/is_const.hpp"
+#include "boost/type_traits/is_same.hpp"
+#include "boost/utility/enable_if.hpp"
+#include "boost/variant/recursive_wrapper_fwd.hpp"
+#include "boost/variant/static_visitor.hpp"
+
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/begin_end.hpp"
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/not.hpp"
+#include "boost/mpl/empty.hpp"
+#include "boost/mpl/find_if.hpp"
+#include "boost/mpl/front.hpp"
+#include "boost/mpl/identity.hpp"
+#include "boost/mpl/if.hpp"
+#include "boost/mpl/int.hpp"
+#include "boost/mpl/is_sequence.hpp"
+#include "boost/mpl/iterator_range.hpp"
+#include "boost/mpl/iter_fold_if.hpp"
+#include "boost/mpl/logical.hpp"
+#include "boost/mpl/max_element.hpp"
+#include "boost/mpl/next.hpp"
+#include "boost/mpl/deref.hpp"
+#include "boost/mpl/pair.hpp"
+#include "boost/mpl/protect.hpp"
+#include "boost/mpl/push_front.hpp"
+#include "boost/mpl/same_as.hpp"
+#include "boost/mpl/size_t.hpp"
+#include "boost/mpl/sizeof.hpp"
+#include "boost/mpl/transform.hpp"
+#include "boost/mpl/assert.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// Implementation Macros:
+//
+// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+//   Defined in boost/variant/detail/visitation_impl.hpp.
+//
+// BOOST_VARIANT_MINIMIZE_SIZE
+//   When #defined, implementation employs all known means to minimize the
+//   size of variant obje   cts. However, often unsuccessful due to alignment
+//   issues, and potentially harmful to runtime speed, so not enabled by
+//   default. (TODO: Investigate further.)
+
+#if defined(BOOST_VARIANT_MINIMIZE_SIZE)
+#   include <climits> // for SCHAR_MAX
+#   include "boost/mpl/eval_if.hpp"
+#   include "boost/mpl/equal_to.hpp"
+#   include "boost/mpl/identity.hpp"
+#   include "boost/mpl/int.hpp"
+#   include "boost/mpl/if.hpp"
+#   include "boost/mpl/less.hpp"
+#   include "boost/mpl/long.hpp"
+#   include "boost/mpl/O1_size.hpp"
+#endif
+
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction max_value
+//
+// Finds the maximum value of the unary metafunction F over Sequence.
+//
+template <typename Sequence, typename F>
+struct max_value
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::transform1<Sequence, F>::type transformed_;
+    typedef typename mpl::max_element<transformed_
+          
+        >::type max_it;
+
+public: // metafunction result
+
+    typedef typename mpl::deref<max_it>::type
+        type;
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction find_fallback_type
+//
+// Provides a fallback (i.e., nothrow default-constructible) type from the
+// specified sequence, or no_fallback_type if not found.
+//
+// This implementation is designed to prefer boost::blank over other potential
+// fallback types, regardless of its position in the specified sequence.
+//
+
+class no_fallback_type;
+
+struct find_fallback_type_pred
+{
+    template <typename Iterator>
+    struct apply
+    {
+    private:
+        typedef typename mpl::deref<Iterator>::type t_;
+
+    public:
+        typedef mpl::not_< has_nothrow_constructor<t_> > type;
+    };
+};
+
+template <typename Types>
+struct find_fallback_type
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::end<Types>::type end_it;
+
+    // [Find the first suitable fallback type...]
+
+    typedef typename mpl::iter_fold_if<
+          Types
+        , mpl::int_<0>, mpl::protect< mpl::next<> >
+        , mpl::protect< find_fallback_type_pred >
+        >::type first_result_;
+
+    typedef typename first_result_::first first_result_index;
+    typedef typename first_result_::second first_result_it;
+
+    // [...now search the rest of the sequence for boost::blank...]
+
+    typedef typename mpl::iter_fold_if<
+          mpl::iterator_range< first_result_it,end_it >
+        , first_result_index, mpl::protect< mpl::next<> >
+        , mpl::protect< mpl::not_same_as<boost::blank> >
+        >::type second_result_;
+
+    typedef typename second_result_::second second_result_it;
+
+public: // metafunction result
+
+    // [...and return the results of the search:]
+    typedef typename mpl::eval_if<
+          is_same< second_result_it,end_it >
+        , mpl::if_<
+              is_same< first_result_it,end_it >
+            , mpl::pair< no_fallback_type,no_fallback_type >
+            , first_result_
+            >
+        , mpl::identity< second_result_ >
+        >::type type;
+
+};
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+
+template<>
+struct find_fallback_type<int>
+{
+    typedef mpl::pair< no_fallback_type,no_fallback_type > type;
+};
+
+#endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction make_storage
+//
+// Provides an aligned storage type capable of holding any of the types
+// specified in the given type-sequence.
+//
+
+template <typename Types, typename NeverUsesBackupFlag>
+struct make_storage
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::eval_if<
+          NeverUsesBackupFlag
+        , mpl::identity< Types >
+        , mpl::push_front<
+              Types, backup_holder<void*>
+            >
+        >::type types;
+
+    typedef typename max_value<
+          types, mpl::sizeof_<mpl::_1>
+        >::type max_size;
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+
+    typedef typename max_value<
+          types, alignment_of<mpl::_1>
+        >::type max_alignment;
+
+#else // borland
+
+    // temporary workaround -- use maximal alignment
+    typedef mpl::size_t< -1 > max_alignment;
+
+#endif // borland workaround
+
+public: // metafunction result
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+    typedef ::boost::aligned_storage<
+          BOOST_MPL_AUX_VALUE_WKND(max_size)::value
+        , BOOST_MPL_AUX_VALUE_WKND(max_alignment)::value
+        > type;
+
+#else // MSVC7 and below
+
+    BOOST_STATIC_CONSTANT(std::size_t, msvc_max_size_c = max_size::value);
+    BOOST_STATIC_CONSTANT(std::size_t, msvc_max_alignment_c = max_alignment::value);
+
+    typedef ::boost::aligned_storage<
+          msvc_max_size_c
+        , msvc_max_alignment_c
+        > type;
+
+#endif // MSVC workaround
+
+};
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+
+template<>
+struct make_storage<int,int>
+{
+    typedef int type;
+};
+
+#endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class destroyer
+//
+// Internal visitor that destroys the value it visits.
+//
+struct destroyer
+    : public static_visitor<>
+{
+public: // visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(T& operand, int) const
+    {
+        operand.~T();
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) || \
+    BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+        operand; // suppresses warnings
+#endif
+
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template known_get
+//
+// Visitor that returns a reference to content of the specified type.
+//
+// Precondition: visited variant MUST contain logical content of type T.
+//
+template <typename T>
+class known_get
+    : public static_visitor<T&>
+{
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+public: // visitor interface
+
+    T& operator()(T& operand) const
+    {
+        return operand;
+    }
+
+    template <typename U>
+    T& operator()(U&) const
+    {
+        // logical error to be here: see precondition above
+        BOOST_ASSERT(false);
+        return ::boost::detail::variant::forced_return< T& >();
+    }
+
+#else // MSVC6
+
+private: // helpers, for visitor interface (below)
+
+    T& execute(T& operand, mpl::true_) const
+    {
+        return operand;
+    }
+
+    template <typename U>
+    T& execute(U& operand, mpl::false_) const
+    {
+        // logical error to be here: see precondition above
+        BOOST_ASSERT(false);
+        return ::boost::detail::variant::forced_return< T& >();
+    }
+
+public: // visitor interface
+
+    template <typename U>
+    T& operator()(U& operand) const
+    {
+        typedef typename is_same< U,T >::type
+            U_is_T;
+
+        return execute(operand, U_is_T());
+    }
+
+#endif // MSVC6 workaround
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class copy_into
+//
+// Internal visitor that copies the value it visits into the given buffer.
+//
+class copy_into
+    : public static_visitor<>
+{
+private: // representation
+
+    void* storage_;
+
+public: // structors
+
+    explicit copy_into(void* storage)
+        : storage_(storage)
+    {
+    }
+
+public: // internal visitor interface
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( operand.get() );
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( operand.get() );
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const T& operand, int) const
+    {
+        new(storage_) T(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class assign_storage
+//
+// Internal visitor that assigns the given storage (which must be a
+// constructed value of the same type) to the value it visits.
+//
+struct assign_storage
+    : public static_visitor<>
+{
+private: // representation
+
+    const void* rhs_storage_;
+
+public: // structors
+
+    explicit assign_storage(const void* rhs_storage)
+        : rhs_storage_(rhs_storage)
+    {
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(T& lhs_content, int) const
+    {
+        // NOTE TO USER :
+        // Compile error here indicates one of variant's bounded types does
+        // not meet the requirements of the Assignable concept. Thus,
+        // variant is not Assignable.
+        //
+        // Hint: Are any of the bounded types const-qualified or references?
+        //
+        lhs_content = *static_cast< const T* >(rhs_storage_);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class direct_assigner
+//
+// Generic static visitor that: if and only if the visited value is of the
+// specified type, assigns the given value to the visited value and returns
+// true; else returns false.
+//
+template <typename T>
+class direct_assigner
+    : public static_visitor<bool>
+{
+private: // representation
+
+    const T& rhs_;
+
+public: // structors
+
+    explicit direct_assigner(const T& rhs)
+        : rhs_(rhs)
+    {
+    }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+public: // visitor interface
+
+    bool operator()(T& lhs)
+    {
+        lhs = rhs_;
+        return true;
+    }
+
+    template <typename U>
+    bool operator()(U&)
+    {
+        return false;
+    }
+
+#else // MSVC6
+
+private: // helpers, for visitor interface (below)
+
+    bool execute(T& lhs, mpl::true_)
+    {
+        lhs = rhs_;
+        return true;
+    }
+
+    template <typename U>
+    bool execute(U&, mpl::false_)
+    {
+        return false;
+    }
+
+public: // visitor interface
+
+    template <typename U>
+    bool operator()(U& lhs)
+    {
+        typedef typename is_same<U,T>::type U_is_T;
+        return execute(lhs, U_is_T());
+    }
+
+#endif // MSVC6 workaround
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    direct_assigner& operator= (direct_assigner const&);
+#endif
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class backup_assigner
+//
+// Internal visitor that "assigns" the given value to the visited value,
+// using backup to recover if the destroy-copy sequence fails.
+//
+// NOTE: This needs to be a friend of variant, as it needs access to
+// indicate_which, indicate_backup_which, etc.
+//
+template <typename Variant, typename RhsT>
+class backup_assigner
+    : public static_visitor<>
+{
+private: // representation
+
+    Variant& lhs_;
+    int rhs_which_;
+    const RhsT& rhs_content_;
+
+public: // structors
+
+    backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content)
+        : lhs_(lhs)
+        , rhs_which_(rhs_which)
+        , rhs_content_(rhs_content)
+    {
+    }
+
+private: // helpers, for visitor interface (below)
+
+    template <typename LhsT>
+    void backup_assign_impl(
+          LhsT& lhs_content
+        , mpl::true_// has_nothrow_move
+        )
+    {
+        // Move lhs content to backup...
+        LhsT backup_lhs_content(
+              ::boost::detail::variant::move(lhs_content)
+            ); // nothrow
+
+        // ...destroy lhs content...
+        lhs_content.~LhsT(); // nothrow
+
+        try
+        {
+            // ...and attempt to copy rhs content into lhs storage:
+            new(lhs_.storage_.address()) RhsT(rhs_content_);
+        }
+        catch (...)
+        {
+            // In case of failure, restore backup content to lhs storage...
+            new(lhs_.storage_.address())
+                LhsT(
+                      ::boost::detail::variant::move(backup_lhs_content)
+                    ); // nothrow
+
+            // ...and rethrow:
+            throw;
+        }
+
+        // In case of success, indicate new content type:
+        lhs_.indicate_which(rhs_which_); // nothrow
+    }
+
+    template <typename LhsT>
+    void backup_assign_impl(
+          LhsT& lhs_content
+        , mpl::false_// has_nothrow_move
+        )
+    {
+        // Backup lhs content...
+        LhsT* backup_lhs_ptr = new LhsT(lhs_content);
+
+        // ...destroy lhs content...
+        lhs_content.~LhsT(); // nothrow
+
+        try
+        {
+            // ...and attempt to copy rhs content into lhs storage:
+            new(lhs_.storage_.address()) RhsT(rhs_content_);
+        }
+        catch (...)
+        {
+            // In case of failure, copy backup pointer to lhs storage...
+            new(lhs_.storage_.address())
+                backup_holder<LhsT>( backup_lhs_ptr ); // nothrow
+
+            // ...indicate now using backup...
+            lhs_.indicate_backup_which( lhs_.which() ); // nothrow
+
+            // ...and rethrow:
+            throw;
+        }
+
+        // In case of success, indicate new content type...
+        lhs_.indicate_which(rhs_which_); // nothrow
+
+        // ...and delete backup:
+        delete backup_lhs_ptr; // nothrow
+    }
+
+public: // visitor interface
+
+    template <typename LhsT>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(LhsT& lhs_content, int)
+    {
+        typedef typename has_nothrow_move_constructor<LhsT>::type
+            nothrow_move;
+
+        backup_assign_impl( lhs_content, nothrow_move() );
+
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    backup_assigner& operator= (backup_assigner const&);
+#endif
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class swap_with
+//
+// Visitor that swaps visited value with content of given variant.
+//
+// Precondition: Given variant MUST have same logical type as visited value.
+//
+template <typename Variant>
+struct swap_with
+    : public static_visitor<>
+{
+private: // representation
+
+    Variant& toswap_;
+
+public: // structors
+
+    explicit swap_with(Variant& toswap)
+        : toswap_(toswap)
+    {
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+    void operator()(T& operand) const
+    {
+        // Since the precondition ensures types are same, get T...
+        known_get<T> getter;
+        T& other = toswap_.apply_visitor(getter);
+
+        // ...and swap:
+        ::boost::detail::variant::move_swap( operand, other );
+    }
+
+private:
+    swap_with& operator=(const swap_with&);
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class reflect
+//
+// Generic static visitor that performs a typeid on the value it visits.
+//
+
+#if !defined(BOOST_NO_TYPEID)
+
+class reflect
+    : public static_visitor<const std::type_info&>
+{
+public: // visitor interfaces
+
+    template <typename T>
+    const std::type_info& operator()(const T&) const
+    {
+        return typeid(T);
+    }
+
+};
+
+#endif // BOOST_NO_TYPEID
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class comparer
+//
+// Generic static visitor that compares the content of the given lhs variant
+// with the visited rhs content using Comp.
+//
+// Precondition: lhs.which() == rhs.which()
+//
+template <typename Variant, typename Comp>
+class comparer
+    : public static_visitor<bool>
+{
+private: // representation
+
+    const Variant& lhs_;
+
+public: // structors
+
+    explicit comparer(const Variant& lhs)
+        : lhs_(lhs)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename T>
+    bool operator()(const T& rhs_content) const
+    {
+        // Since the precondition ensures lhs and rhs types are same, get T...
+        known_get<const T> getter;
+        const T& lhs_content = lhs_.apply_visitor(getter);
+
+        // ...and compare lhs and rhs contents:
+        return Comp()(lhs_content, rhs_content);
+    }
+
+private:
+    comparer& operator=(const comparer&);
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class equal_comp
+//
+// Generic function object compares lhs with rhs using operator==.
+//
+struct equal_comp
+{
+    template <typename T>
+    bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs == rhs;
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class less_comp
+//
+// Generic function object compares lhs with rhs using operator<.
+//
+struct less_comp
+{
+    template <typename T>
+    bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs < rhs;
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template invoke_visitor
+//
+// Internal visitor that invokes the given visitor using:
+//  * for wrappers (e.g., recursive_wrapper), the wrapper's held value.
+//  * for all other values, the value itself.
+//
+template <typename Visitor>
+class invoke_visitor
+{
+private: // representation
+
+    Visitor& visitor_;
+
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+public: // structors
+
+    explicit invoke_visitor(Visitor& visitor)
+        : visitor_(visitor)
+    {
+    }
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+public: // internal visitor interfaces
+
+    template <typename T>
+    result_type internal_visit(T& operand, int)
+    {
+        return visitor_(operand);
+    }
+
+#   if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))
+    template <typename T>
+    result_type internal_visit(const T& operand, int)
+    {
+        return visitor_(operand);
+    }
+#   endif
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+private: // helpers, for internal visitor interfaces (below)
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    visit_impl(T& operand, mpl::false_)
+    {
+        return visitor_(operand);
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    visit_impl(T& operand, mpl::true_)
+    {
+        visitor_(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(T& operand, int)
+    {
+        typedef typename is_same<result_type, void>::type
+            has_void_result_type;
+
+        return visit_impl(operand, has_void_result_type());
+    }
+
+#endif // BOOST_NO_VOID_RETURNS) workaround
+
+public: // internal visitor interfaces, cont.
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(boost::recursive_wrapper<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(const boost::recursive_wrapper<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(boost::detail::reference_content<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(const boost::detail::reference_content<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    invoke_visitor& operator= (invoke_visitor const&);
+#endif
+};
+
+}} // namespace detail::variant
+
+///////////////////////////////////////////////////////////////////////////////
+// class template variant (concept inspired by Andrei Alexandrescu)
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template <
+      typename T0_
+    , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)
+    >
+class variant
+{
+private: // helpers, for typedefs (below)
+
+    typedef variant wknd_self_t;
+
+    struct is_recursive_
+        : detail::variant::is_recursive_flag<T0_>
+    {
+    };
+
+    typedef typename mpl::eval_if<
+          is_recursive_
+        , T0_
+        , mpl::identity< T0_ >
+        >::type unwrapped_T0_;
+
+    struct is_sequence_based_
+        : detail::variant::is_over_sequence<unwrapped_T0_>
+    {
+    };
+
+#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+private: // helpers, for typedefs (below)
+
+    typedef typename mpl::eval_if<
+          is_sequence_based_
+        , unwrapped_T0_ // over_sequence<...>::type
+        , detail::variant::make_variant_list<
+              unwrapped_T0_
+            , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+            >
+        >::type specified_types;
+
+    BOOST_STATIC_ASSERT((
+          ::boost::mpl::not_< mpl::empty<specified_types> >::value
+        ));
+
+    typedef typename mpl::eval_if<
+          is_recursive_
+        , mpl::transform<
+              specified_types
+            , mpl::protect<
+                  detail::variant::quoted_enable_recursive<wknd_self_t>
+                >
+            >
+        , mpl::identity< specified_types >
+        >::type recursive_enabled_types;
+
+public: // public typedefs
+
+    typedef typename mpl::transform<
+          recursive_enabled_types
+        , unwrap_recursive<mpl::_1>
+        >::type types;
+
+private: // internal typedefs
+
+    typedef typename mpl::transform<
+          recursive_enabled_types
+        , mpl::protect< detail::make_reference_content<> >
+        >::type internal_types;
+
+    typedef typename mpl::front<
+          internal_types
+        >::type internal_T0;
+
+#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+private: // helpers, for typedefs (below)
+
+    typedef unwrapped_T0_ T0;
+
+    #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \
+        typedef typename mpl::eval_if< \
+              is_recursive_ \
+            , detail::variant::enable_recursive< \
+                  BOOST_PP_CAT(T,N) \
+                , wknd_self_t \
+                > \
+            , mpl::identity< BOOST_PP_CAT(T,N) > \
+            >::type BOOST_PP_CAT(recursive_enabled_T,N); \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+
+    #define BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS(z,N,_) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS
+
+public: // public typedefs
+
+    typedef typename detail::variant::make_variant_list<
+          BOOST_VARIANT_ENUM_PARAMS(public_T)
+        >::type types;
+
+private: // helpers, for internal typedefs (below)
+
+    #define BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS(z,N,_) \
+        typedef detail::make_reference_content< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(internal_T,N); \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS
+
+private: // internal typedefs
+
+    typedef typename detail::variant::make_variant_list<
+          BOOST_VARIANT_ENUM_PARAMS(internal_T)
+        >::type internal_types;
+
+private: // static precondition assertions
+
+    // NOTE TO USER :
+    // variant< type-sequence > syntax is not supported on this compiler!
+    //
+    BOOST_MPL_ASSERT_NOT(( is_sequence_based_ ));
+
+#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround
+
+private: // helpers, for representation (below)
+
+    typedef typename detail::variant::find_fallback_type<
+          internal_types
+        >::type fallback_type_result_;
+
+    typedef typename fallback_type_result_::first
+        fallback_type_index_;
+    typedef typename fallback_type_result_::second
+        fallback_type_;
+
+    struct has_fallback_type_
+        : mpl::not_<
+              is_same< fallback_type_, detail::variant::no_fallback_type >
+            >
+    {
+    };
+
+    typedef has_fallback_type_
+        never_uses_backup_flag;
+
+    typedef typename detail::variant::make_storage<
+          internal_types, never_uses_backup_flag
+        >::type storage_t;
+
+private: // helpers, for representation (below)
+
+    // which_ on:
+    // * [0,  size<internal_types>) indicates stack content
+    // * [-size<internal_types>, 0) indicates pointer to heap backup
+    // if which_ >= 0:
+    // * then which() -> which_
+    // * else which() -> -(which_ + 1)
+
+#if !defined(BOOST_VARIANT_MINIMIZE_SIZE)
+
+    typedef int which_t;
+
+#else // defined(BOOST_VARIANT_MINIMIZE_SIZE)
+
+    // [if O1_size available, then attempt which_t size optimization...]
+    // [select signed char if fewer than SCHAR_MAX types, else signed int:]
+    typedef typename mpl::eval_if<
+          mpl::equal_to< mpl::O1_size<internal_types>, mpl::long_<-1> >
+        , mpl::identity< int >
+        , mpl::if_<
+              mpl::less< mpl::O1_size<internal_types>, mpl::int_<SCHAR_MAX> >
+            , signed char
+            , int
+            >
+        >::type which_t;
+
+#endif // BOOST_VARIANT_MINIMIZE_SIZE switch
+
+// representation -- private when possible
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    private:
+#else
+    public:
+#endif
+
+    which_t which_;
+    storage_t storage_;
+
+    void indicate_which(int which)
+    {
+        which_ = static_cast<which_t>( which );
+    }
+
+    void indicate_backup_which(int which)
+    {
+        which_ = static_cast<which_t>( -(which + 1) );
+    }
+
+private: // helpers, for queries (below)
+
+    bool using_backup() const
+    {
+        return which_ < 0;
+    }
+
+public: // queries
+
+    int which() const
+    {
+        // If using heap backup...
+        if (using_backup())
+            // ...then return adjusted which_:
+            return -(which_ + 1);
+
+        // Otherwise, return which_ directly:
+        return which_;
+    }
+
+private: // helpers, for structors (below)
+
+    struct initializer
+        : BOOST_VARIANT_AUX_INITIALIZER_T(
+              recursive_enabled_types, recursive_enabled_T
+            )
+    {
+    };
+
+    void destroy_content()
+    {
+        detail::variant::destroyer visitor;
+        this->internal_apply_visitor(visitor);
+    }
+
+public: // structors
+
+    ~variant()
+    {
+        destroy_content();
+    }
+
+    variant()
+    {
+        // NOTE TO USER :
+        // Compile error from here indicates that the first bound
+        // type is not default-constructible, and so variant cannot
+        // support its own default-construction.
+        //
+        new( storage_.address() ) internal_T0();
+        indicate_which(0); // zero is the index of the first bounded type
+    }
+
+private: // helpers, for structors, cont. (below)
+
+    class convert_copy_into
+        : public static_visitor<int>
+    {
+    private: // representation
+
+        void* storage_;
+
+    public: // structors
+
+        explicit convert_copy_into(void* storage)
+            : storage_(storage)
+        {
+        }
+
+    public: // internal visitor interfaces (below)
+
+        template <typename T>
+        int internal_visit(T& operand, int) const
+        {
+            // NOTE TO USER :
+            // Compile error here indicates one of the source variant's types 
+            // cannot be unambiguously converted to the destination variant's
+            // types (or that no conversion exists).
+            //
+            return initializer::initialize(storage_, operand);
+        }
+
+#   if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))
+        template <typename T>
+        result_type internal_visit(const T& operand, int) const
+        {
+            return initializer::initialize(storage_, operand);
+        }
+#   endif
+
+        template <typename T>
+        int internal_visit(boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+    };
+
+    friend class convert_copy_into;
+
+private: // helpers, for structors, below 
+
+    template <typename T>
+    void convert_construct(
+          T& operand
+        , int
+        , mpl::false_ = mpl::false_() // is_foreign_variant
+        )
+    {
+        // NOTE TO USER :
+        // Compile error here indicates that the given type is not 
+        // unambiguously convertible to one of the variant's types
+        // (or that no conversion exists).
+        //
+        indicate_which(
+              initializer::initialize(
+                  storage_.address()
+                , operand
+                )
+            );
+    }
+
+    template <typename Variant>
+    void convert_construct(
+          Variant& operand
+        , long
+        , mpl::true_// is_foreign_variant
+        )
+    {
+        convert_copy_into visitor(storage_.address());
+        indicate_which(
+              operand.internal_apply_visitor(visitor)
+            );
+    }
+
+    template <typename Variant>
+    void convert_construct_variant(Variant& operand)
+    {
+        // [Determine if the given variant is itself a bounded type, or if its
+        //  content needs to be converted (i.e., it is a 'foreign' variant):]
+        //
+
+        typedef typename mpl::find_if<
+              types
+            , is_same<
+                  add_const<mpl::_1>
+                , const Variant
+                >
+            >::type found_it;
+
+        typedef typename mpl::end<types>::type not_found;
+        typedef typename is_same<
+              found_it, not_found
+            >::type is_foreign_variant;
+
+        // Convert construct from operand:
+        convert_construct(
+              operand, 1L
+            , is_foreign_variant()
+            );
+    }
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
+    void convert_construct(
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
+        , long
+        )
+    {
+        convert_construct_variant(operand);
+    }
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
+    void convert_construct(
+          const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
+        , long
+        )
+    {
+        convert_construct_variant(operand);    
+    }
+
+public: // structors, cont.
+
+#if !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING)
+
+    template <typename T>
+    variant(const T& operand)
+    {
+        convert_construct(operand, 1L);
+    }
+
+    template <typename T>
+    variant(T& operand)
+    {
+        convert_construct(operand, 1L);
+    }
+
+#elif defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
+
+    // For compilers that cannot distinguish between T& and const T& in
+    // template constructors, but do fully support SFINAE, we can workaround:
+
+    template <typename T>
+    variant(const T& operand)
+    {
+        convert_construct(operand, 1L);
+    }
+
+    template <typename T>
+    variant(
+          T& operand
+        , typename enable_if<
+              mpl::not_< is_const<T> >
+            , void
+            >::type* = 0
+        )
+    {
+        convert_construct(operand, 1L);
+    }
+
+#else // !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
+
+    // For compilers that cannot distinguish between T& and const T& in
+    // template constructors, and do NOT support SFINAE, we can't workaround:
+
+    template <typename T>
+    variant(const T& operand)
+    {
+        convert_construct(operand, 1L);
+    }
+
+#endif // BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING workarounds
+
+public: // structors, cont.
+
+    // [MSVC6 requires copy constructor appear after template constructors]
+    variant(const variant& operand)
+    {
+        // Copy the value of operand into *this...
+        detail::variant::copy_into visitor( storage_.address() );
+        operand.internal_apply_visitor(visitor);
+
+        // ...and activate the *this's primary storage on success:
+        indicate_which(operand.which());
+    }
+
+private: // helpers, for modifiers (below)
+
+#   if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template <typename Variant, typename RhsT>
+    friend class detail::variant::backup_assigner;
+#   endif
+
+    // class assigner
+    //
+    // Internal visitor that "assigns" the visited value to the given variant
+    // by appropriate destruction and copy-construction.
+    //
+
+    class assigner
+        : public static_visitor<>
+    {
+    private: // representation
+
+        variant& lhs_;
+        int rhs_which_;
+
+    public: // structors
+
+        assigner(variant& lhs, int rhs_which)
+            : lhs_(lhs)
+            , rhs_which_(rhs_which)
+        {
+        }
+
+    private: // helpers, for internal visitor interface (below)
+
+        template <typename RhsT, typename B1, typename B2>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::true_// has_nothrow_copy
+            , B1// has_nothrow_move_constructor
+            , B2// has_fallback_type
+            )
+        {
+            // Destroy lhs's content...
+            lhs_.destroy_content(); // nothrow
+
+            // ...copy rhs content into lhs's storage...
+            new(lhs_.storage_.address())
+                RhsT( rhs_content ); // nothrow
+
+            // ...and indicate new content type:
+            lhs_.indicate_which(rhs_which_); // nothrow
+        }
+
+        template <typename RhsT, typename B>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_// has_nothrow_copy
+            , mpl::true_// has_nothrow_move_constructor
+            , B// has_fallback_type
+            )
+        {
+            // Attempt to make a temporary copy (so as to move it below)...
+            RhsT temp(rhs_content);
+
+            // ...and upon success destroy lhs's content...
+            lhs_.destroy_content(); // nothrow
+
+            // ...move the temporary copy into lhs's storage...
+            new(lhs_.storage_.address())
+                RhsT( detail::variant::move(temp) ); // nothrow
+
+            // ...and indicate new content type:
+            lhs_.indicate_which(rhs_which_); // nothrow
+        }
+
+        template <typename RhsT>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_// has_nothrow_copy
+            , mpl::false_// has_nothrow_move_constructor
+            , mpl::true_// has_fallback_type
+            )
+        {
+            // Destroy lhs's content...
+            lhs_.destroy_content(); // nothrow
+
+            try
+            {
+                // ...and attempt to copy rhs's content into lhs's storage:
+                new(lhs_.storage_.address())
+                    RhsT( rhs_content );
+            }
+            catch (...)
+            {
+                // In case of failure, default-construct fallback type in lhs's storage...
+                new (lhs_.storage_.address())
+                    fallback_type_; // nothrow
+
+                // ...indicate construction of fallback type...
+                lhs_.indicate_which(
+                      BOOST_MPL_AUX_VALUE_WKND(fallback_type_index_)::value
+                    ); // nothrow
+
+                // ...and rethrow:
+                throw;
+            }
+
+            // In the event of success, indicate new content type:
+            lhs_.indicate_which(rhs_which_); // nothrow
+        }
+
+        template <typename RhsT>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_// has_nothrow_copy
+            , mpl::false_// has_nothrow_move_constructor
+            , mpl::false_// has_fallback_type
+            )
+        {
+            detail::variant::backup_assigner<wknd_self_t, RhsT>
+                visitor(lhs_, rhs_which_, rhs_content);
+            lhs_.internal_apply_visitor(visitor);
+        }
+
+    public: // internal visitor interfaces
+
+        template <typename RhsT>
+            BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+        internal_visit(const RhsT& rhs_content, int)
+        {
+            typedef typename has_nothrow_copy<RhsT>::type
+                nothrow_copy;
+            typedef typename mpl::or_< // reduces compile-time
+                  nothrow_copy
+                , detail::variant::has_nothrow_move_constructor<RhsT>
+                >::type nothrow_move_constructor;
+
+            assign_impl(
+                  rhs_content
+                , nothrow_copy()
+                , nothrow_move_constructor()
+                , has_fallback_type_()
+                );
+
+            BOOST_VARIANT_AUX_RETURN_VOID;
+        }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        assigner& operator= (assigner const&);
+#endif
+    };
+
+    friend class assigner;
+
+    void variant_assign(const variant& rhs)
+    {
+        // If the contained types are EXACTLY the same...
+        if (which_ == rhs.which_)
+        {
+            // ...then assign rhs's storage to lhs's content:
+            detail::variant::assign_storage visitor(rhs.storage_.address());
+            this->internal_apply_visitor(visitor);
+        }
+        else
+        {
+            // Otherwise, perform general (copy-based) variant assignment:
+            assigner visitor(*this, rhs.which());
+            rhs.internal_apply_visitor(visitor); 
+        }
+    }
+
+private: // helpers, for modifiers (below)
+
+    template <typename T>
+    void assign(const T& rhs)
+    {
+        // If direct T-to-T assignment is not possible...
+        detail::variant::direct_assigner<T> direct_assign(rhs);
+        if (this->apply_visitor(direct_assign) == false)
+        {
+            // ...then convert rhs to variant and assign:
+            //
+            // While potentially inefficient, the following construction of a
+            // variant allows T as any type convertible to one of the bounded
+            // types without excessive code redundancy.
+            //
+            variant temp(rhs);
+            variant_assign( detail::variant::move(temp) );
+        }
+    }
+
+public: // modifiers
+
+    template <typename T>
+    variant& operator=(const T& rhs)
+    {
+        assign(rhs);
+        return *this;
+    }
+
+    // [MSVC6 requires copy assign appear after templated operator=]
+    variant& operator=(const variant& rhs)
+    {
+        variant_assign(rhs);
+        return *this;
+    }
+
+    void swap(variant& rhs)
+    {
+        // If the contained types are the same...
+        if (which() == rhs.which())
+        {
+            // ...then swap the values directly:
+            detail::variant::swap_with<variant> visitor(rhs);
+            this->apply_visitor(visitor);
+        }
+        else
+        {
+            // ...otherwise, perform general variant swap:
+            variant tmp( detail::variant::move(rhs) );
+            rhs = detail::variant::move(*this);
+            *this = detail::variant::move(tmp);
+        }
+    }
+
+public: // queries
+
+    //
+    // NOTE: member which() defined above.
+    //
+
+    bool empty() const
+    {
+        return false;
+    }
+
+#if !defined(BOOST_NO_TYPEID)
+    const std::type_info& type() const
+    {
+        detail::variant::reflect visitor;
+        return this->apply_visitor(visitor);
+    }
+#endif
+
+public: // prevent comparison with foreign types
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+#   define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \
+    void
+
+#else // MSVC7
+
+    //
+    // MSVC7 gives error about return types for above being different than
+    // the true comparison operator overloads:
+    //
+
+#   define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \
+    bool
+
+#endif // MSVC7 workaround
+
+    template <typename U>
+        BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE
+    operator==(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+    template <typename U>
+        BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE
+    operator<(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+public: // comparison operators
+
+    // [MSVC6 requires these operators appear after template operators]
+
+    bool operator==(const variant& rhs) const
+    {
+        if (this->which() != rhs.which())
+            return false;
+
+        detail::variant::comparer<
+              variant, detail::variant::equal_comp
+            > visitor(*this);
+        return rhs.apply_visitor(visitor);
+    }
+
+    bool operator<(const variant& rhs) const
+    {
+        //
+        // Dirk Schreib suggested this collating order.
+        //
+
+        if (this->which() != rhs.which())
+            return this->which() < rhs.which();
+
+        detail::variant::comparer<
+              variant, detail::variant::less_comp
+            > visitor(*this);
+        return rhs.apply_visitor(visitor);
+    }
+
+// helpers, for visitation support (below) -- private when possible
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+
+    template < BOOST_VARIANT_ENUM_PARAMS(typename U) >
+    friend class variant;
+
+private:
+
+#else// defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+
+public:
+
+#endif// !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+
+    template <typename Visitor, typename VoidPtrCV>
+    static
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    internal_apply_visitor_impl(
+          int internal_which
+        , int logical_which
+        , Visitor& visitor
+        , VoidPtrCV storage
+        )
+    {
+        typedef mpl::int_<0> first_which;
+        typedef typename mpl::begin<internal_types>::type first_it;
+        typedef typename mpl::end<internal_types>::type last_it;
+
+        typedef detail::variant::visitation_impl_step<
+              first_it, last_it
+            > first_step;
+
+        return detail::variant::visitation_impl(
+              internal_which, logical_which
+            , visitor, storage, mpl::false_()
+            , never_uses_backup_flag()
+            , static_cast<first_which*>(0), static_cast<first_step*>(0)
+            );
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    internal_apply_visitor(Visitor& visitor)
+    {
+        return internal_apply_visitor_impl(
+              which_, which(), visitor, storage_.address()
+            );
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    internal_apply_visitor(Visitor& visitor) const
+    {
+        return internal_apply_visitor_impl(
+              which_, which(), visitor, storage_.address()
+            );
+    }
+
+public: // visitation support
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    apply_visitor(Visitor& visitor)
+    {
+        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    apply_visitor(Visitor& visitor) const
+    {
+        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+
+}; // class variant
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_variant_over
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template <typename Types>
+struct make_variant_over
+{
+private: // precondition assertions
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value ));
+#endif
+
+public: // metafunction result
+
+    typedef variant<
+          detail::variant::over_sequence< Types >
+        > type;
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// function template swap
+//
+// Swaps two variants of the same type (i.e., identical specification).
+//
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline void swap(
+      variant< BOOST_VARIANT_ENUM_PARAMS(T) >& lhs
+    , variant< BOOST_VARIANT_ENUM_PARAMS(T) >& rhs
+    )
+{
+    lhs.swap(rhs);
+}
+
+} // namespace boost
+
+// implementation additions
+
+#if !defined(BOOST_NO_IOSTREAM)
+#include "boost/variant/detail/variant_io.hpp"
+#endif // BOOST_NO_IOSTREAM
+
+#endif // BOOST_VARIANT_VARIANT_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/variant_fwd.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/variant_fwd.hpp
new file mode 100644 (file)
index 0000000..7482ad4
--- /dev/null
@@ -0,0 +1,253 @@
+//-----------------------------------------------------------------------------
+// boost variant/variant_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 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_VARIANT_VARIANT_FWD_HPP
+#define BOOST_VARIANT_VARIANT_FWD_HPP
+
+#include "boost/variant/detail/config.hpp"
+
+#include "boost/blank_fwd.hpp"
+#include "boost/mpl/arg.hpp"
+#include "boost/mpl/limits/arity.hpp"
+#include "boost/mpl/aux_/na.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/enum.hpp"
+#include "boost/preprocessor/enum_params.hpp"
+#include "boost/preprocessor/enum_shifted_params.hpp"
+#include "boost/preprocessor/repeat.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_LIMIT_TYPES
+//
+// Implementation-defined preprocessor symbol describing the actual
+// length of variant's pseudo-variadic template parameter list.
+//
+#include "boost/mpl/limits/list.hpp"
+#define BOOST_VARIANT_LIMIT_TYPES \
+    BOOST_MPL_LIMIT_LIST_SIZE
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_REFERENCE_SUPPORT
+//
+// Defined if variant does not support references as bounded types. 
+//
+#if defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) \
+ && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) \
+ && !defined(BOOST_VARIANT_NO_REFERENCE_SUPPORT)
+#   define BOOST_VARIANT_NO_REFERENCE_SUPPORT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
+//
+// Defined if variant does not support make_variant_over (see below). 
+//
+#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   define BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
+//
+// Defined if make_recursive_variant cannot be supported as documented.
+//
+// Note: Currently, MPL lambda facility is used as workaround if defined, and
+// so only types declared w/ MPL lambda workarounds will work.
+//
+
+#include "boost/variant/detail/substitute_fwd.hpp"
+
+#if defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) \
+ && !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+#   define BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY
+//
+// Exposes maximum allowed arity of class templates with recursive_variant
+// arguments. That is,
+//   make_recursive_variant< ..., T<[1], recursive_variant_, ... [N]> >.
+//
+#include "boost/mpl/limits/arity.hpp"
+#define BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY \
+    BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_ENUM_PARAMS
+//
+// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES params.
+//
+// Rationale: Cleaner, simpler code for clients of variant library.
+//
+#define BOOST_VARIANT_ENUM_PARAMS( param )  \
+    BOOST_PP_ENUM_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_ENUM_SHIFTED_PARAMS
+//
+// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES-1 params.
+//
+#define BOOST_VARIANT_ENUM_SHIFTED_PARAMS( param )  \
+    BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
+
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class void_ and class template convert_void
+// 
+// Provides the mechanism by which void(NN) types are converted to
+// mpl::void_ (and thus can be passed to mpl::list).
+//
+// Rationale: This is particularly needed for the using-declarations
+// workaround (below), but also to avoid associating mpl namespace with
+// variant in argument dependent lookups (which used to happen because of
+// defaulting of template parameters to mpl::void_).
+//
+
+struct void_;
+
+template <typename T>
+struct convert_void
+{
+    typedef T type;
+};
+
+template <>
+struct convert_void< void_ >
+{
+    typedef mpl::na type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (workaround) BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+//
+// Needed to work around compilers that don't support using-declaration
+// overloads. (See the variant::initializer workarounds below.)
+//
+
+#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+// (detail) tags voidNN -- NN defined on [0, BOOST_VARIANT_LIMIT_TYPES)
+//
+// Defines void types that are each unique and specializations of
+// convert_void that yields mpl::na for each voidNN type.
+//
+
+#define BOOST_VARIANT_DETAIL_DEFINE_VOID_N(z,N,_)          \
+    struct BOOST_PP_CAT(void,N);                           \
+                                                           \
+    template <>                                            \
+    struct convert_void< BOOST_PP_CAT(void,N) >            \
+    {                                                      \
+        typedef mpl::na type;                              \
+    };                                                     \
+    /**/
+
+BOOST_PP_REPEAT(
+      BOOST_VARIANT_LIMIT_TYPES
+    , BOOST_VARIANT_DETAIL_DEFINE_VOID_N
+    , _
+    )
+
+#undef BOOST_VARIANT_DETAIL_DEFINE_VOID_N
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+}} // namespace detail::variant
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) macro BOOST_VARIANT_AUX_DECLARE_PARAM
+//
+// Template parameter list for variant and recursive_variant declarations.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
+    typename BOOST_PP_CAT(T,N) = detail::variant::void_ \
+    /**/
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
+    typename BOOST_PP_CAT(T,N) = BOOST_PP_CAT(detail::variant::void,N) \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#define BOOST_VARIANT_AUX_DECLARE_PARAMS \
+    BOOST_PP_ENUM( \
+          BOOST_VARIANT_LIMIT_TYPES \
+        , BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL \
+        , T \
+        ) \
+    /**/
+
+///////////////////////////////////////////////////////////////////////////////
+// class template variant (concept inspired by Andrei Alexandrescu)
+//
+// Efficient, type-safe bounded discriminated union.
+//
+// Preconditions:
+//  - Each type must be unique.
+//  - No type may be const-qualified.
+//
+// Proper declaration form:
+//   variant<types>    (where types is a type-sequence)
+// or
+//   variant<T0,T1,...,Tn>  (where T0 is NOT a type-sequence)
+//
+template < BOOST_VARIANT_AUX_DECLARE_PARAMS > class variant;
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant
+//
+// Exposes a boost::variant with recursive_variant_ tags (below) substituted
+// with the variant itself (wrapped as needed with boost::recursive_wrapper).
+//
+template < BOOST_VARIANT_AUX_DECLARE_PARAMS > struct make_recursive_variant;
+
+#undef BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL
+#undef BOOST_VARIANT_AUX_DECLARE_PARAMS
+
+///////////////////////////////////////////////////////////////////////////////
+// type recursive_variant_
+//
+// Tag type indicates where recursive variant substitution should occur.
+//
+#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+    struct recursive_variant_;
+#else
+    typedef mpl::arg<1> recursive_variant_;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_variant_over
+//
+// Result is a variant w/ types of the specified type sequence.
+//
+template <typename Types> struct make_variant_over;
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant_over
+//
+// Result is a recursive variant w/ types of the specified type sequence.
+//
+template <typename Types> struct make_recursive_variant_over;
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_VARIANT_FWD_HPP
diff --git a/deal.II/contrib/boost-1.46.1/include/boost/variant/visitor_ptr.hpp b/deal.II/contrib/boost-1.46.1/include/boost/variant/visitor_ptr.hpp
new file mode 100644 (file)
index 0000000..b49a972
--- /dev/null
@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------------
+// boost variant/visitor_ptr.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-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_VARIANT_VISITOR_PTR_HPP
+#define BOOST_VARIANT_VISITOR_PTR_HPP
+
+#include "boost/variant/bad_visit.hpp"
+#include "boost/variant/static_visitor.hpp"
+
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/identity.hpp"
+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/type_traits/is_void.hpp"
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template visitor_ptr
+//
+// Adapts a function pointer for use as visitor capable of handling
+// values of a single type. Throws bad_visit if inappropriately applied.
+//
+template <typename T, typename R>
+class visitor_ptr_t
+    : public static_visitor<R>
+{
+private: // representation
+
+    typedef R (*visitor_t)(T);
+
+    visitor_t visitor_;
+
+public: // typedefs
+
+    typedef R result_type;
+
+private: // private typedefs
+
+    typedef typename mpl::eval_if<
+          is_reference<T>
+        , mpl::identity<T>
+        , add_reference<const T>
+        >::type argument_fwd_type;
+
+public: // structors
+
+    explicit visitor_ptr_t(visitor_t visitor)
+      : visitor_(visitor)
+    {
+    }
+
+public: // static visitor interfaces
+
+    template <typename U>
+    result_type operator()(const U&) const
+    {
+        throw bad_visit();
+    }
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+public: // static visitor interfaces, cont.
+
+    result_type operator()(argument_fwd_type operand) const
+    {
+        return visitor_(operand);
+    }
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+private: // helpers, for static visitor interfaces (below)
+
+    result_type execute_impl(argument_fwd_type operand, mpl::false_) const
+    {
+        return visitor_(operand);
+    }
+
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    execute_impl(argument_fwd_type operand, mpl::true_) const
+    {
+        visitor_(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+public: // static visitor interfaces, cont.
+
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(argument_fwd_type operand) const
+    {
+        typedef typename is_void<result_type>::type has_void_result;
+        return execute_impl(operand, has_void_result());
+    }
+
+#endif // BOOST_NO_VOID_RETURNS workaround
+
+};
+
+template <typename R, typename T>
+inline visitor_ptr_t<T,R> visitor_ptr(R (*visitor)(T))
+{
+    return visitor_ptr_t<T,R>(visitor);
+}
+
+} // namespace boost
+
+#endif// BOOST_VISITOR_VISITOR_PTR_HPP

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.