From: bangerth Date: Wed, 5 Mar 2008 03:24:55 +0000 (+0000) Subject: Import the Boost Graph Library and whatever else is necessary to use it to compute... X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=7398b683eda2b0bcb737ca4ee94a041c10ac227f;p=dealii-svn.git Import the Boost Graph Library and whatever else is necessary to use it to compute Cuthill McKee reorderings and similar things. git-svn-id: https://svn.dealii.org/trunk@15855 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/contrib/boost/include/boost/bind/apply.hpp b/deal.II/contrib/boost/include/boost/bind/apply.hpp new file mode 100644 index 0000000000..6a43a89ac8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/apply.hpp @@ -0,0 +1,74 @@ +#ifndef BOOST_BIND_APPLY_HPP_INCLUDED +#define BOOST_BIND_APPLY_HPP_INCLUDED + +// +// apply.hpp +// +// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +namespace boost +{ + +template struct apply +{ + typedef R result_type; + + template result_type operator()(F & f) const + { + return f(); + } + + template result_type operator()(F & f, A1 & a1) const + { + return f(a1); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2) const + { + return f(a1, a2); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const + { + return f(a1, a2, a3); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const + { + return f(a1, a2, a3, a4); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const + { + return f(a1, a2, a3, a4, a5); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const + { + return f(a1, a2, a3, a4, a5, a6); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const + { + return f(a1, a2, a3, a4, a5, a6, a7); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const + { + return f(a1, a2, a3, a4, a5, a6, a7, a8); + } + + template result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const + { + return f(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } +}; + +} // namespace boost + +#endif // #ifndef BOOST_BIND_APPLY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/bind/arg.hpp b/deal.II/contrib/boost/include/boost/bind/arg.hpp new file mode 100644 index 0000000000..90e966e5f4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/arg.hpp @@ -0,0 +1,36 @@ +#ifndef BOOST_BIND_ARG_HPP_INCLUDED +#define BOOST_BIND_ARG_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// bind/arg.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/bind.html for documentation. +// + +namespace boost +{ + +template class arg +{ +}; + +template bool operator==(arg const &, arg const &) +{ + return true; +} + +} // namespace boost + +#endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/bind/bind_cc.hpp b/deal.II/contrib/boost/include/boost/bind/bind_cc.hpp new file mode 100644 index 0000000000..35f8eceb9e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/bind_cc.hpp @@ -0,0 +1,117 @@ +// +// bind/bind_cc.hpp - support for different calling conventions +// +// Do not include this header directly. +// +// Copyright (c) 2001 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/bind.html for documentation. +// + +template + _bi::bind_t + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) ()) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (); + typedef _bi::list0 list_type; + return _bi::bind_t (f, list_type()); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1), A1 a1) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1); + typedef typename _bi::list_av_1::type list_type; + return _bi::bind_t (f, list_type(a1)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2); + typedef typename _bi::list_av_2::type list_type; + return _bi::bind_t (f, list_type(a1, a2)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3); + typedef typename _bi::list_av_3::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4); + typedef typename _bi::list_av_4::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3, a4)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5); + typedef typename _bi::list_av_5::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6); + typedef typename _bi::list_av_6::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7); + typedef typename _bi::list_av_7::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8); + typedef typename _bi::list_av_8::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); +} + +template + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) +{ + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9); + typedef typename _bi::list_av_9::type list_type; + return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); +} diff --git a/deal.II/contrib/boost/include/boost/bind/bind_mf_cc.hpp b/deal.II/contrib/boost/include/boost/bind/bind_mf_cc.hpp new file mode 100644 index 0000000000..88be8222f3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/bind_mf_cc.hpp @@ -0,0 +1,227 @@ +// +// bind/bind_mf_cc.hpp - support for different calling conventions +// +// Do not include this header directly. +// +// Copyright (c) 2001 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/bind.html for documentation. +// + +// 0 + +template + _bi::bind_t, typename _bi::list_av_1::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf0) F; + typedef typename _bi::list_av_1::type list_type; + return _bi::bind_t(F(f), list_type(a1)); +} + +template + _bi::bind_t, typename _bi::list_av_1::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf0) F; + typedef typename _bi::list_av_1::type list_type; + return _bi::bind_t(F(f), list_type(a1)); +} + +// 1 + +template + _bi::bind_t, typename _bi::list_av_2::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf1) F; + typedef typename _bi::list_av_2::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2)); +} + +template + _bi::bind_t, typename _bi::list_av_2::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf1) F; + typedef typename _bi::list_av_2::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2)); +} + +// 2 + +template + _bi::bind_t, typename _bi::list_av_3::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf2) F; + typedef typename _bi::list_av_3::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3)); +} + +template + _bi::bind_t, typename _bi::list_av_3::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf2) F; + typedef typename _bi::list_av_3::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3)); +} + +// 3 + +template + _bi::bind_t, typename _bi::list_av_4::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf3) F; + typedef typename _bi::list_av_4::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4)); +} + +template + _bi::bind_t, typename _bi::list_av_4::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf3) F; + typedef typename _bi::list_av_4::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4)); +} + +// 4 + +template + _bi::bind_t, typename _bi::list_av_5::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf4) F; + typedef typename _bi::list_av_5::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5)); +} + +template + _bi::bind_t, typename _bi::list_av_5::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf4) F; + typedef typename _bi::list_av_5::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5)); +} + +// 5 + +template + _bi::bind_t, typename _bi::list_av_6::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf5) F; + typedef typename _bi::list_av_6::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6)); +} + +template + _bi::bind_t, typename _bi::list_av_6::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf5) F; + typedef typename _bi::list_av_6::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6)); +} + +// 6 + +template + _bi::bind_t, typename _bi::list_av_7::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf6) F; + typedef typename _bi::list_av_7::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6, a7)); +} + +template + _bi::bind_t, typename _bi::list_av_7::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf6) F; + typedef typename _bi::list_av_7::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6, a7)); +} + +// 7 + +template + _bi::bind_t, typename _bi::list_av_8::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf7) F; + typedef typename _bi::list_av_8::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8)); +} + +template + _bi::bind_t, typename _bi::list_av_8::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf7) F; + typedef typename _bi::list_av_8::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8)); +} + +// 8 + +template + _bi::bind_t, typename _bi::list_av_9::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) +{ + typedef _mfi::BOOST_BIND_MF_NAME(mf8) F; + typedef typename _bi::list_av_9::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); +} + +template + _bi::bind_t, typename _bi::list_av_9::type> + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) +{ + typedef _mfi::BOOST_BIND_MF_NAME(cmf8) F; + typedef typename _bi::list_av_9::type list_type; + return _bi::bind_t(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); +} diff --git a/deal.II/contrib/boost/include/boost/bind/bind_template.hpp b/deal.II/contrib/boost/include/boost/bind/bind_template.hpp new file mode 100644 index 0000000000..60d78b31bb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/bind_template.hpp @@ -0,0 +1,161 @@ +// +// bind/bind_template.hpp +// +// Do not include this header directly. +// +// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/bind.html for documentation. +// + + typedef typename result_traits::type result_type; + + result_type operator()() + { + list0 a; + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + result_type operator()() const + { + list0 a; + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1) + { + list1 a(a1); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1) const + { + list1 a(a1); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2) + { + list2 a(a1, a2); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2) const + { + list2 a(a1, a2); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3) + { + list3 a(a1, a2, a3); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3) const + { + list3 a(a1, a2, a3); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) + { + list4 a(a1, a2, a3, a4); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const + { + list4 a(a1, a2, a3, a4); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) + { + list5 a(a1, a2, a3, a4, a5); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const + { + list5 a(a1, a2, a3, a4, a5); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) + { + list6 a(a1, a2, a3, a4, a5, a6); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const + { + list6 a(a1, a2, a3, a4, a5, a6); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) + { + list7 a(a1, a2, a3, a4, a5, a6, a7); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const + { + list7 a(a1, a2, a3, a4, a5, a6, a7); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) + { + list8 a(a1, a2, a3, a4, a5, a6, a7, a8); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const + { + list8 a(a1, a2, a3, a4, a5, a6, a7, a8); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) + { + list9 a(a1, a2, a3, a4, a5, a6, a7, a8, a9); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const + { + list9 a(a1, a2, a3, a4, a5, a6, a7, a8, a9); + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type eval(A & a) + { + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template result_type eval(A & a) const + { + BOOST_BIND_RETURN l_(type(), f_, a, 0); + } + + template void accept(V & v) const + { + BOOST_BIND_VISIT_EACH(v, f_, 0); + l_.accept(v); + } + + bool compare(this_type const & rhs) const + { + return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_; + } + +private: + + F f_; + L l_; diff --git a/deal.II/contrib/boost/include/boost/bind/make_adaptable.hpp b/deal.II/contrib/boost/include/boost/bind/make_adaptable.hpp new file mode 100644 index 0000000000..b9f083e307 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/make_adaptable.hpp @@ -0,0 +1,187 @@ +#ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED +#define BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED + +// +// make_adaptable.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +namespace boost +{ + +namespace _bi +{ + +template class af0 +{ +public: + + typedef R result_type; + + explicit af0(F f): f_(f) + { + } + + result_type operator()() + { + return f_(); + } + + result_type operator()() const + { + return f_(); + } + +private: + + F f_; +}; + +template class af1 +{ +public: + + typedef R result_type; + typedef A1 argument_type; + typedef A1 arg1_type; + + explicit af1(F f): f_(f) + { + } + + result_type operator()(A1 a1) + { + return f_(a1); + } + + result_type operator()(A1 a1) const + { + return f_(a1); + } + +private: + + F f_; +}; + +template class af2 +{ +public: + + typedef R result_type; + typedef A1 first_argument_type; + typedef A2 second_argument_type; + typedef A1 arg1_type; + typedef A2 arg2_type; + + explicit af2(F f): f_(f) + { + } + + result_type operator()(A1 a1, A2 a2) + { + return f_(a1, a2); + } + + result_type operator()(A1 a1, A2 a2) const + { + return f_(a1, a2); + } + +private: + + F f_; +}; + +template class af3 +{ +public: + + typedef R result_type; + typedef A1 arg1_type; + typedef A2 arg2_type; + typedef A3 arg3_type; + + explicit af3(F f): f_(f) + { + } + + result_type operator()(A1 a1, A2 a2, A3 a3) + { + return f_(a1, a2, a3); + } + + result_type operator()(A1 a1, A2 a2, A3 a3) const + { + return f_(a1, a2, a3); + } + +private: + + F f_; +}; + +template class af4 +{ +public: + + typedef R result_type; + typedef A1 arg1_type; + typedef A2 arg2_type; + typedef A3 arg3_type; + typedef A4 arg4_type; + + explicit af4(F f): f_(f) + { + } + + result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) + { + return f_(a1, a2, a3, a4); + } + + result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const + { + return f_(a1, a2, a3, a4); + } + +private: + + F f_; +}; + +} // namespace _bi + +template _bi::af0 make_adaptable(F f) +{ + return _bi::af0(f); +} + +template _bi::af1 make_adaptable(F f) +{ + return _bi::af1(f); +} + +template _bi::af2 make_adaptable(F f) +{ + return _bi::af2(f); +} + +template _bi::af3 make_adaptable(F f) +{ + return _bi::af3(f); +} + +template _bi::af4 make_adaptable(F f) +{ + return _bi::af4(f); +} + +} // namespace boost + +#endif // #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/bind/mem_fn_cc.hpp b/deal.II/contrib/boost/include/boost/bind/mem_fn_cc.hpp new file mode 100644 index 0000000000..8b6ea0ba13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/mem_fn_cc.hpp @@ -0,0 +1,103 @@ +// +// bind/mem_fn_cc.hpp - support for different calling conventions +// +// Do not include this header directly. +// +// Copyright (c) 2001 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/mem_fn.html for documentation. +// + +template _mfi::BOOST_MEM_FN_NAME(mf0) mem_fn(R (BOOST_MEM_FN_CC T::*f) ()) +{ + return _mfi::BOOST_MEM_FN_NAME(mf0)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf0) mem_fn(R (BOOST_MEM_FN_CC T::*f) () const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf0)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf1) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf1)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf1) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf1)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf2) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf2)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf2) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf2)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf3) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf3)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf3) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf3)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf4) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf4)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf4) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf4)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf5) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf5)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf5) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf5)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf6) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf6)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf6) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf6)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf7) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf7)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf7) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf7)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(mf8) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8)) +{ + return _mfi::BOOST_MEM_FN_NAME(mf8)(f); +} + +template _mfi::BOOST_MEM_FN_NAME(cmf8) mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const) +{ + return _mfi::BOOST_MEM_FN_NAME(cmf8)(f); +} diff --git a/deal.II/contrib/boost/include/boost/bind/mem_fn_template.hpp b/deal.II/contrib/boost/include/boost/bind/mem_fn_template.hpp new file mode 100644 index 0000000000..6368bf25c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/mem_fn_template.hpp @@ -0,0 +1,934 @@ +// +// bind/mem_fn_template.hpp +// +// Do not include this header directly +// +// Copyright (c) 2001 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/mem_fn.html for documentation. +// + +// mf0 + +template class BOOST_MEM_FN_NAME(mf0) +{ +public: + + typedef R result_type; + typedef T * argument_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ()) + F f_; + + template R call(U & u, T const *) const + { + BOOST_MEM_FN_RETURN (u.*f_)(); + } + + template R call(U & u, void const *) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {} + + R operator()(T * p) const + { + BOOST_MEM_FN_RETURN (p->*f_)(); + } + + template R operator()(U & u) const + { + BOOST_MEM_FN_RETURN call(u, &u); + } + + R operator()(T & t) const + { + BOOST_MEM_FN_RETURN (t.*f_)(); + } + + bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf0 + +template class BOOST_MEM_FN_NAME(cmf0) +{ +public: + + typedef R result_type; + typedef T const * argument_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const) + F f_; + + template R call(U & u, T const *) const + { + BOOST_MEM_FN_RETURN (u.*f_)(); + } + + template R call(U & u, void const *) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {} + + template R operator()(U const & u) const + { + BOOST_MEM_FN_RETURN call(u, &u); + } + + R operator()(T const & t) const + { + BOOST_MEM_FN_RETURN (t.*f_)(); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf1 + +template class BOOST_MEM_FN_NAME(mf1) +{ +public: + + typedef R result_type; + typedef T * first_argument_type; + typedef A1 second_argument_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1)) + F f_; + + template R call(U & u, T const *, B1 & b1) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1); + } + + template R call(U & u, void const *, B1 & b1) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {} + + R operator()(T * p, A1 a1) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1); + } + + template R operator()(U & u, A1 a1) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1); + } + + R operator()(T & t, A1 a1) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1); + } + + bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf1 + +template class BOOST_MEM_FN_NAME(cmf1) +{ +public: + + typedef R result_type; + typedef T const * first_argument_type; + typedef A1 second_argument_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const) + F f_; + + template R call(U & u, T const *, B1 & b1) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1); + } + + template R call(U & u, void const *, B1 & b1) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1); + } + + R operator()(T const & t, A1 a1) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf2 + +template class BOOST_MEM_FN_NAME(mf2) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2); + } + + template R operator()(U & u, A1 a1, A2 a2) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2); + } + + R operator()(T & t, A1 a1, A2 a2) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2); + } + + bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf2 + +template class BOOST_MEM_FN_NAME(cmf2) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1, A2 a2) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2); + } + + R operator()(T const & t, A1 a1, A2 a2) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf3 + +template class BOOST_MEM_FN_NAME(mf3) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2, A3 a3) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3); + } + + template R operator()(U & u, A1 a1, A2 a2, A3 a3) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3); + } + + R operator()(T & t, A1 a1, A2 a2, A3 a3) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3); + } + + bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf3 + +template class BOOST_MEM_FN_NAME(cmf3) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1, A2 a2, A3 a3) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3); + } + + R operator()(T const & t, A1 a1, A2 a2, A3 a3) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf4 + +template class BOOST_MEM_FN_NAME(mf4) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4); + } + + template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4); + } + + R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4); + } + + bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf4 + +template class BOOST_MEM_FN_NAME(cmf4) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4); + } + + R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf5 + +template class BOOST_MEM_FN_NAME(mf5) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5); + } + + template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5); + } + + R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5); + } + + bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf5 + +template class BOOST_MEM_FN_NAME(cmf5) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5); + } + + R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf6 + +template class BOOST_MEM_FN_NAME(mf6) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6); + } + + template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6); + } + + R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6); + } + + bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf6 + +template class BOOST_MEM_FN_NAME(cmf6) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6); + } + + R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf7 + +template class BOOST_MEM_FN_NAME(mf7) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7); + } + + template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7); + } + + R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7); + } + + bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf7 + +template class BOOST_MEM_FN_NAME(cmf7) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {} + + template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7); + } + + R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// mf8 + +template class BOOST_MEM_FN_NAME(mf8) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8)) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + } + +public: + + explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {} + + R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + } + + template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8); + } + + R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + } + + bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const + { + return f_ != rhs.f_; + } +}; + +// cmf8 + +template class BOOST_MEM_FN_NAME(cmf8) +{ +public: + + typedef R result_type; + +private: + + BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const) + F f_; + + template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const + { + BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + } + + template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const + { + BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + } + +public: + + explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {} + + R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const + { + BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + } + + template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const + { + BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8); + } + + R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const + { + BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + } + + bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const + { + return f_ == rhs.f_; + } + + bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const + { + return f_ != rhs.f_; + } +}; + diff --git a/deal.II/contrib/boost/include/boost/bind/mem_fn_vw.hpp b/deal.II/contrib/boost/include/boost/bind/mem_fn_vw.hpp new file mode 100644 index 0000000000..f3fc58db04 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/mem_fn_vw.hpp @@ -0,0 +1,130 @@ +// +// bind/mem_fn_vw.hpp - void return helper wrappers +// +// Do not include this header directly +// +// Copyright (c) 2001 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/mem_fn.html for documentation. +// + +template struct BOOST_MEM_FN_NAME(mf0): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (); + explicit BOOST_MEM_FN_NAME(mf0)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf0): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0) +{ + typedef R (BOOST_MEM_FN_CC T::*F) () const; + explicit BOOST_MEM_FN_NAME(cmf0)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf1): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1); + explicit BOOST_MEM_FN_NAME(mf1)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf1): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1) const; + explicit BOOST_MEM_FN_NAME(cmf1)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf2): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2); + explicit BOOST_MEM_FN_NAME(mf2)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf2): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const; + explicit BOOST_MEM_FN_NAME(cmf2)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf3): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3); + explicit BOOST_MEM_FN_NAME(mf3)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf3): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const; + explicit BOOST_MEM_FN_NAME(cmf3)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf4): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4); + explicit BOOST_MEM_FN_NAME(mf4)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf4): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const; + explicit BOOST_MEM_FN_NAME(cmf4)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf5): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5); + explicit BOOST_MEM_FN_NAME(mf5)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf5): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const; + explicit BOOST_MEM_FN_NAME(cmf5)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf6): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6); + explicit BOOST_MEM_FN_NAME(mf6)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf6): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const; + explicit BOOST_MEM_FN_NAME(cmf6)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf7): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7); + explicit BOOST_MEM_FN_NAME(mf7)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf7): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const; + explicit BOOST_MEM_FN_NAME(cmf7)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)(f) {} +}; + + +template struct BOOST_MEM_FN_NAME(mf8): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8); + explicit BOOST_MEM_FN_NAME(mf8)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)(f) {} +}; + +template struct BOOST_MEM_FN_NAME(cmf8): public mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8) +{ + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const; + explicit BOOST_MEM_FN_NAME(cmf8)(F f): mf::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)(f) {} +}; + diff --git a/deal.II/contrib/boost/include/boost/bind/placeholders.hpp b/deal.II/contrib/boost/include/boost/bind/placeholders.hpp new file mode 100644 index 0000000000..8feed58905 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/placeholders.hpp @@ -0,0 +1,68 @@ +#ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED +#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// bind/placeholders.hpp - _N definitions +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/bind/bind.html for documentation. +// + +#include +#include + +namespace +{ + +#if defined(__BORLANDC__) + +static inline boost::arg<1> _1() { return boost::arg<1>(); } +static inline boost::arg<2> _2() { return boost::arg<2>(); } +static inline boost::arg<3> _3() { return boost::arg<3>(); } +static inline boost::arg<4> _4() { return boost::arg<4>(); } +static inline boost::arg<5> _5() { return boost::arg<5>(); } +static inline boost::arg<6> _6() { return boost::arg<6>(); } +static inline boost::arg<7> _7() { return boost::arg<7>(); } +static inline boost::arg<8> _8() { return boost::arg<8>(); } +static inline boost::arg<9> _9() { return boost::arg<9>(); } + +#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) + +static boost::arg<1> _1; +static boost::arg<2> _2; +static boost::arg<3> _3; +static boost::arg<4> _4; +static boost::arg<5> _5; +static boost::arg<6> _6; +static boost::arg<7> _7; +static boost::arg<8> _8; +static boost::arg<9> _9; + +#else + +boost::arg<1> _1; +boost::arg<2> _2; +boost::arg<3> _3; +boost::arg<4> _4; +boost::arg<5> _5; +boost::arg<6> _6; +boost::arg<7> _7; +boost::arg<8> _8; +boost::arg<9> _9; + +#endif + +} // unnamed namespace + +#endif // #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/bind/protect.hpp b/deal.II/contrib/boost/include/boost/bind/protect.hpp new file mode 100644 index 0000000000..b1ff2a2a8e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/bind/protect.hpp @@ -0,0 +1,144 @@ +#ifndef BOOST_BIND_PROTECT_HPP_INCLUDED +#define BOOST_BIND_PROTECT_HPP_INCLUDED + +// +// protect.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +namespace boost +{ + +namespace _bi +{ + +template class protected_bind_t +{ +public: + + typedef typename F::result_type result_type; + + explicit protected_bind_t(F f): f_(f) + { + } + + result_type operator()() + { + return f_(); + } + + result_type operator()() const + { + return f_(); + } + + template result_type operator()(A1 & a1) + { + return f_(a1); + } + + template result_type operator()(A1 & a1) const + { + return f_(a1); + } + + template result_type operator()(A1 & a1, A2 & a2) + { + return f_(a1, a2); + } + + template result_type operator()(A1 & a1, A2 & a2) const + { + return f_(a1, a2); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3) + { + return f_(a1, a2, a3); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3) const + { + return f_(a1, a2, a3); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) + { + return f_(a1, a2, a3, a4); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const + { + return f_(a1, a2, a3, a4); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) + { + return f_(a1, a2, a3, a4, a5); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const + { + return f_(a1, a2, a3, a4, a5); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) + { + return f_(a1, a2, a3, a4, a5, a6); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const + { + return f_(a1, a2, a3, a4, a5, a6); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) + { + return f_(a1, a2, a3, a4, a5, a6, a7); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const + { + return f_(a1, a2, a3, a4, a5, a6, a7); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) + { + return f_(a1, a2, a3, a4, a5, a6, a7, a8); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const + { + return f_(a1, a2, a3, a4, a5, a6, a7, a8); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) + { + return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } + + template result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const + { + return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } + +private: + + F f_; +}; + +} // namespace _bi + +template _bi::protected_bind_t protect(F f) +{ + return _bi::protected_bind_t(f); +} + +} // namespace boost + +#endif // #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/graph/adjacency_iterator.hpp b/deal.II/contrib/boost/include/boost/graph/adjacency_iterator.hpp new file mode 100644 index 0000000000..d500606443 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/adjacency_iterator.hpp @@ -0,0 +1,102 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_ADJACENCY_ITERATOR_HPP +#define BOOST_ADJACENCY_ITERATOR_HPP + +#include +#include + +namespace boost +{ + + template + struct adjacency_iterator + : iterator_adaptor< + adjacency_iterator + , OutEdgeIter + , Vertex + , use_default + , Vertex + , Difference + > + { + typedef iterator_adaptor< + adjacency_iterator + , OutEdgeIter + , Vertex + , use_default + , Vertex + , Difference + > super_t; + + inline adjacency_iterator() {} + inline adjacency_iterator(OutEdgeIter const& i, const Graph* g) : super_t(i), m_g(g) { } + + inline Vertex + dereference() const + { return target(*this->base(), *m_g); } + + const Graph* m_g; + }; + + template ::vertex_descriptor, + class OutEdgeIter=typename graph_traits::out_edge_iterator> + class adjacency_iterator_generator + { + typedef typename boost::detail::iterator_traits + ::difference_type difference_type; + public: + typedef adjacency_iterator type; + }; + + template + struct inv_adjacency_iterator + : iterator_adaptor< + inv_adjacency_iterator + , InEdgeIter + , Vertex + , use_default + , Vertex + , Difference + > + { + typedef iterator_adaptor< + inv_adjacency_iterator + , InEdgeIter + , Vertex + , use_default + , Vertex + , Difference + > super_t; + + inline inv_adjacency_iterator() { } + inline inv_adjacency_iterator(InEdgeIter const& i, const Graph* g) : super_t(i), m_g(g) { } + + inline Vertex + dereference() const + { return source(*this->base(), *m_g); } + + const Graph* m_g; + }; + + template ::vertex_descriptor, + class InEdgeIter = typename graph_traits::in_edge_iterator> + class inv_adjacency_iterator_generator { + typedef typename boost::detail::iterator_traits + ::difference_type difference_type; + public: + typedef inv_adjacency_iterator type; + }; + +} // namespace boost + +#endif // BOOST_DETAIL_ADJACENCY_ITERATOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/adjacency_list.hpp b/deal.II/contrib/boost/include/boost/graph/adjacency_list.hpp new file mode 100644 index 0000000000..b92b9feb26 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/adjacency_list.hpp @@ -0,0 +1,536 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_ADJACENCY_LIST_HPP +#define BOOST_GRAPH_ADJACENCY_LIST_HPP + + +#include + +#include +#include +#include + +#if !defined BOOST_NO_HASH +#include +#endif + +#if !defined BOOST_NO_SLIST +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + //=========================================================================== + // Selectors for the VertexList and EdgeList template parameters of + // adjacency_list, and the container_gen traits class which is used + // to map the selectors to the container type used to implement the + // graph. + // + // The main container_gen traits class uses partial specialization, + // so we also include a workaround. + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#if !defined BOOST_NO_SLIST + struct slistS {}; +#endif + + struct vecS { }; + struct listS { }; + struct setS { }; + struct multisetS { }; + struct mapS { }; +#if !defined BOOST_NO_HASH + struct hash_mapS { }; + struct hash_setS { }; +#endif + + template + struct container_gen { }; + + template + struct container_gen { + typedef std::list type; + }; +#if !defined BOOST_NO_SLIST + template + struct container_gen { + typedef BOOST_STD_EXTENSION_NAMESPACE::slist type; + }; +#endif + template + struct container_gen { + typedef std::vector type; + }; + + template + struct container_gen { + typedef std::set type; + }; + + template + struct container_gen { + typedef std::set type; + }; + + template + struct container_gen { + typedef std::multiset type; + }; + +#if !defined BOOST_NO_HASH + template + struct container_gen { + typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set type; + }; + + template + struct container_gen { + typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set type; + }; +#endif + +#else // !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#if !defined BOOST_NO_SLIST + struct slistS { + template + struct bind_ { typedef std::slist type; }; + }; +#endif + + struct vecS { + template + struct bind_ { typedef std::vector type; }; + }; + + struct listS { + template + struct bind_ { typedef std::list type; }; + }; + + struct setS { + template + struct bind_ { typedef std::set > type; }; + }; + + struct multisetS { + template + struct bind_ { typedef std::multiset > type; }; + }; + +#if !defined BOOST_NO_HASH + struct hash_setS { + template + struct bind_ { typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set > type; }; + }; +#endif + + struct mapS { + template + struct bind_ { typedef std::set > type; }; + }; + +#if !defined BOOST_NO_HASH + struct hash_mapS { + template + struct bind_ { typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set > type; }; + }; +#endif + + template struct container_selector { + typedef vecS type; + }; + +#define BOOST_CONTAINER_SELECTOR(NAME) \ + template <> struct container_selector { \ + typedef NAME type; \ + } + + BOOST_CONTAINER_SELECTOR(vecS); + BOOST_CONTAINER_SELECTOR(listS); + BOOST_CONTAINER_SELECTOR(mapS); + BOOST_CONTAINER_SELECTOR(setS); + BOOST_CONTAINER_SELECTOR(multisetS); +#if !defined BOOST_NO_HASH + BOOST_CONTAINER_SELECTOR(hash_mapS); +#endif +#if !defined BOOST_NO_SLIST + BOOST_CONTAINER_SELECTOR(slistS); +#endif + + template + struct container_gen { + typedef typename container_selector::type Select; + typedef typename Select:: template bind_::type type; + }; + +#endif // !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + template + struct parallel_edge_traits { }; + + template <> + struct parallel_edge_traits { + typedef allow_parallel_edge_tag type; }; + + template <> + struct parallel_edge_traits { + typedef allow_parallel_edge_tag type; }; + +#if !defined BOOST_NO_SLIST + template <> + struct parallel_edge_traits { + typedef allow_parallel_edge_tag type; }; +#endif + + template <> + struct parallel_edge_traits { + typedef disallow_parallel_edge_tag type; }; + + template <> + struct parallel_edge_traits { + typedef allow_parallel_edge_tag type; }; + +#if !defined BOOST_NO_HASH + template <> + struct parallel_edge_traits { + typedef disallow_parallel_edge_tag type; + }; +#endif + + // mapS is obsolete, replaced with setS + template <> + struct parallel_edge_traits { + typedef disallow_parallel_edge_tag type; }; + +#if !defined BOOST_NO_HASH + template <> + struct parallel_edge_traits { + typedef disallow_parallel_edge_tag type; + }; +#endif + + namespace detail { + template struct is_random_access { + enum { value = false}; + typedef false_type type; + }; + template <> + struct is_random_access { + enum { value = true }; + typedef true_type type; + }; + + } // namespace detail + + + + //=========================================================================== + // The adjacency_list_traits class, which provides a way to access + // some of the associated types of an adjacency_list type without + // having to first create the adjacency_list type. This is useful + // when trying to create interior vertex or edge properties who's + // value type is a vertex or edge descriptor. + + template + struct adjacency_list_traits + { + typedef typename detail::is_random_access::type + is_rand_access; + typedef typename DirectedS::is_bidir_t is_bidir; + typedef typename DirectedS::is_directed_t is_directed; + + typedef typename boost::ct_if_t::type + >::type directed_category; + + typedef typename parallel_edge_traits::type + edge_parallel_category; + + typedef void* vertex_ptr; + typedef typename boost::ct_if_t::type vertex_descriptor; + typedef detail::edge_desc_impl + edge_descriptor; + }; + +} // namespace boost + +#include + +namespace boost { + + //=========================================================================== + // The adjacency_list class. + // + + template + class adjacency_list + : public detail::adj_list_gen< + adjacency_list, + VertexListS, OutEdgeListS, DirectedS, +#if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES) + typename detail::retag_property_list::type, + typename detail::retag_property_list::type, +#else + VertexProperty, EdgeProperty, +#endif + GraphProperty, EdgeListS>::type + { +#if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES) + typedef typename detail::retag_property_list::retagged + maybe_vertex_bundled; + + typedef typename detail::retag_property_list::retagged + maybe_edge_bundled; +#endif + + public: +#if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES) + typedef typename detail::retag_property_list::type + vertex_property_type; + typedef typename detail::retag_property_list::type + edge_property_type; + + // The types that are actually bundled + typedef typename ct_if<(is_same::value), + no_vertex_bundle, + maybe_vertex_bundled>::type vertex_bundled; + typedef typename ct_if<(is_same::value), + no_edge_bundle, + maybe_edge_bundled>::type edge_bundled; +#else + typedef VertexProperty vertex_property_type; + typedef EdgeProperty edge_property_type; + typedef no_vertex_bundle vertex_bundled; + typedef no_edge_bundle edge_bundled; +#endif + + private: + typedef adjacency_list self; + typedef typename detail::adj_list_gen< + self, VertexListS, OutEdgeListS, DirectedS, + vertex_property_type, edge_property_type, GraphProperty, EdgeListS + >::type Base; + + public: + typedef typename Base::stored_vertex stored_vertex; + typedef typename Base::vertices_size_type vertices_size_type; + typedef typename Base::edges_size_type edges_size_type; + typedef typename Base::degree_size_type degree_size_type; + typedef typename Base::vertex_descriptor vertex_descriptor; + typedef typename Base::edge_descriptor edge_descriptor; + typedef OutEdgeListS out_edge_list_selector; + typedef VertexListS vertex_list_selector; + typedef DirectedS directed_selector; + typedef EdgeListS edge_list_selector; + + typedef GraphProperty graph_property_type; + + inline adjacency_list(const GraphProperty& p = GraphProperty()) + : m_property(p) { } + + inline adjacency_list(const adjacency_list& x) + : Base(x), m_property(x.m_property) { } + + inline adjacency_list& operator=(const adjacency_list& x) { + // TBD: probably should give the strong guarantee + if (&x != this) { + Base::operator=(x); + m_property = x.m_property; + } + return *this; + } + + // Required by Mutable Graph + inline adjacency_list(vertices_size_type num_vertices, + const GraphProperty& p = GraphProperty()) + : Base(num_vertices), m_property(p) { } + +#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300 + // Required by Iterator Constructible Graph + template + inline adjacency_list(EdgeIterator first, EdgeIterator last, + vertices_size_type n, + edges_size_type = 0, + const GraphProperty& p = GraphProperty()) + : Base(n, first, last), m_property(p) { } + + template + inline adjacency_list(EdgeIterator first, EdgeIterator last, + EdgePropertyIterator ep_iter, + vertices_size_type n, + edges_size_type = 0, + const GraphProperty& p = GraphProperty()) + : Base(n, first, last, ep_iter), m_property(p) { } +#endif + + void swap(adjacency_list& x) { + // Is there a more efficient way to do this? + adjacency_list tmp(x); + x = *this; + *this = tmp; + } + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + // Directly access a vertex or edge bundle + vertex_bundled& operator[](vertex_descriptor v) + { return get(vertex_bundle, *this)[v]; } + + const vertex_bundled& operator[](vertex_descriptor v) const + { return get(vertex_bundle, *this)[v]; } + + edge_bundled& operator[](edge_descriptor e) + { return get(edge_bundle, *this)[e]; } + + const edge_bundled& operator[](edge_descriptor e) const + { return get(edge_bundle, *this)[e]; } +#endif + + // protected: (would be protected if friends were more portable) + GraphProperty m_property; + }; + + template + inline void + set_property(adjacency_list& g, Tag, + const Value& value) { + get_property_value(g.m_property, Tag()) = value;; + } + + template + inline + typename graph_property, Tag>::type& + get_property(adjacency_list& g, Tag) { + return get_property_value(g.m_property, Tag()); + } + + template + inline + const + typename graph_property, Tag>::type& + get_property(const adjacency_list& g, Tag) { + return get_property_value(g.m_property, Tag()); + } + + // dwa 09/25/00 - needed to be more explicit so reverse_graph would work. + template + inline Vertex + source(const detail::edge_base& e, + const adjacency_list&) + { + return e.m_source; + } + + template + inline Vertex + target(const detail::edge_base& e, + const adjacency_list&) + { + return e.m_target; + } + + // Support for bundled properties +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + template + inline + typename property_map, T Bundle::*>::type + get(T Bundle::* p, adjacency_list& g) + { + typedef typename property_map, T Bundle::*>::type + result_type; + return result_type(&g, p); + } + + template + inline + typename property_map, T Bundle::*>::const_type + get(T Bundle::* p, adjacency_list const & g) + { + typedef typename property_map, T Bundle::*>::const_type + result_type; + return result_type(&g, p); + } + + template + inline T + get(T Bundle::* p, adjacency_list const & g, const Key& key) + { + return get(get(p, g), key); + } + + template + inline void + put(T Bundle::* p, adjacency_list& g, const Key& key, const T& value) + { + put(get(p, g), key, value); + } + +#endif + + +} // namespace boost + + +#endif // BOOST_GRAPH_ADJACENCY_LIST_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/adjacency_list_io.hpp b/deal.II/contrib/boost/include/boost/graph/adjacency_list_io.hpp new file mode 100644 index 0000000000..437f732d42 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/adjacency_list_io.hpp @@ -0,0 +1,375 @@ +//======================================================================= +// Copyright 2001 Universite Joseph Fourier, Grenoble. +// Author: François Faure +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= + + +#ifndef ______adj_list_io_______ +#define ______adj_list_io_______ + +#include +#include +#include +#include + +// Method read to parse an adjacency list from an input stream. Examples: +// cin >> read( G ); +// cin >> read( G, NodePropertySubset(), EdgepropertySubset() ); +// +// Method write to print an adjacency list to an output stream. Examples: +// cout << write( G ); +// cout << write( G, NodePropertySubset(), EdgepropertySubset() ); + +namespace boost { + +/* outline + - basic property input + - get property subset + - graph parser + - property printer + - graph printer + - user methods +*/ + +//=========================================================================== +// basic property input + +template +std::istream& operator >> ( std::istream& in, property& p ) +{ + in >> p.m_value >> *(static_cast(&p)); // houpla !! + return in; +} + +template +std::istream& operator >> ( std::istream& in, property& p ) +{ + in >> p.m_value; + return in; +} + +inline std::istream& operator >> ( std::istream& in, no_property& ) +{ + return in; +} + +// basic property input +//=========================================================================== +// get property subsets + +// get a single property tagged Stag +template +void get +( property& p, const V& v, Stag s ) +{ + get( *(static_cast(&p)),v,s ); +} + +template +void get +( property& p, const V& v, Stag ) +{ + p.m_value = v; +} + +// get a subset of properties tagged Stag +template +void getSubset +( property& p, const property& s ) +{ + get( p, s.m_value, Stag() ); + getSubset( p, Snext(s) ); +} + +template +void getSubset +( property& p, const property& s ) +{ + get( p, s.m_value, Stag() ); +} + +inline void getSubset +( no_property& p, const no_property& s ) +{ +} + +// get property subset +//=========================================================================== +// graph parser + +template +struct GraphParser +{ + + typedef Graph_t Graph; + + GraphParser( Graph* g ): graph(g) + {} + + GraphParser& operator () ( std::istream& in ) + { + typedef typename graph_traits::vertex_descriptor Vertex; + std::vector nodes; + + typedef enum{ PARSE_NUM_NODES, PARSE_VERTEX, PARSE_EDGE } State; + State state = PARSE_VERTEX; + + unsigned int numLine = 1; + char c; + while ( in.get(c) ) + { + if( c== '#' ) skip(in); + else if( c== 'n' ) state = PARSE_NUM_NODES; + else if( c== 'v' ) state = PARSE_VERTEX; + else if( c== 'e' ) state = PARSE_EDGE; + else if( c== '\n' ) numLine++; + else if( !std::isspace(c) ){ + in.putback(c); + if( state == PARSE_VERTEX ){ + VertexPropertySubset readProp; + if( in >> readProp ) + { + VertexProperty vp; + getSubset( vp, readProp ); + nodes.push_back( add_vertex(vp, *graph) ); + } + else + std::cerr<<"read vertex, parse error at line"<> source >> target; + if( in >> readProp ) + { + EdgeProperty ep; + getSubset( ep, readProp ); + add_edge(nodes[source], nodes[target], ep, *graph); + } + else + std::cerr<<"read edge, parse error at line"<> n ){ + for( int i=0; i +struct PropertyPrinter +{ + typedef typename Property::value_type Value; + typedef typename Property::tag_type Tag; + typedef typename Property::next_type Next; + + PropertyPrinter( Graph& g ):graph(&g){} + + template + PropertyPrinter& operator () ( std::ostream& out, Iterator it ) + { + typename property_map::type ps = get(Tag(), *graph); + out << ps[ *it ] <<" "; + PropertyPrinter print(*graph); + print(out, it); + return (*this); + } +private: + Graph* graph; +}; +template +struct PropertyPrinter +{ + PropertyPrinter( Graph& ){} + + template + PropertyPrinter& operator () ( std::ostream&, Iterator it ){ return *this; } +}; + +// property printer +//========================================================================= +// graph printer + +template +struct EdgePrinter +{ + + typedef Graph_t Graph; + typedef typename graph_traits::vertex_descriptor Vertex; + + EdgePrinter( Graph& g ) + : graph(g) + {} + + const EdgePrinter& operator () ( std::ostream& out ) const + { + // assign indices to vertices + std::map indices; + int num = 0; + typename graph_traits::vertex_iterator vi; + for (vi = vertices(graph).first; vi != vertices(graph).second; ++vi){ + indices[*vi] = num++; + } + + // write edges + PropertyPrinter print_Edge(graph); + out << "e" << std::endl; + typename graph_traits::edge_iterator ei; + for (ei = edges(graph).first; ei != edges(graph).second; ++ei){ + out << indices[source(*ei,graph)] << " " << indices[target(*ei,graph)] << " "; + print_Edge(out,ei); + out << std::endl; + } + out << std::endl; + return (*this); + } + +protected: + + Graph& graph; + +}; + +template +struct GraphPrinter: public EdgePrinter +{ + GraphPrinter( Graph& g ) + : EdgePrinter(g) + {} + + const GraphPrinter& operator () ( std::ostream& out ) const + { + PropertyPrinter printNode(this->graph); + out << "v"<::vertex_iterator vi; + for (vi = vertices(this->graph).first; vi != vertices(this->graph).second; ++vi){ + printNode(out,vi); + out << std::endl; + } + + EdgePrinter::operator ()( out ); + return (*this); + } +}; + +template +struct GraphPrinter + : public EdgePrinter +{ + GraphPrinter( Graph& g ) + : EdgePrinter(g) + {} + + const GraphPrinter& operator () ( std::ostream& out ) const + { + out << "n "<< num_vertices(this->graph) << std::endl; + EdgePrinter::operator ()( out ); + return (*this); + } +}; + +// graph printer +//========================================================================= +// user methods + +/// input stream for reading a graph +template +std::istream& operator >> ( std::istream& in, GraphParser gp ) +{ + gp(in); + return in; +} + +/// graph parser for given subsets of internal vertex and edge properties +template +GraphParser,VP,EP,VPS,EPS> +read( adjacency_list& g, VPS vps, EPS eps ) +{ + return GraphParser,VP,EP,VPS,EPS>(&g); +} + +/// graph parser for all internal vertex and edge properties +template +GraphParser,VP,EP,VP,EP> +read( adjacency_list& g ) +{ + return GraphParser,VP,EP,VP,EP>(&g); +} + + +/// output stream for writing a graph +template +std::ostream& operator << ( std::ostream& out, const GraphPrinter& gp ) +{ + gp(out); + return out; +} + +/// write the graph with given property subsets +template +GraphPrinter,VPS,EPS> +write( adjacency_list& g, VPS, EPS ) +{ + return GraphPrinter,VPS,EPS>(g); +} + +/// write the graph with all internal vertex and edge properties +template +GraphPrinter,VP,EP> +write( adjacency_list& g ) +{ + return GraphPrinter,VP,EP>(g); +} + +// user methods +//========================================================================= +}// boost +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/adjacency_matrix.hpp b/deal.II/contrib/boost/include/boost/graph/adjacency_matrix.hpp new file mode 100644 index 0000000000..92f8d09e2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/adjacency_matrix.hpp @@ -0,0 +1,1064 @@ +//======================================================================= +// Copyright 2001 University of Notre Dame. +// Author: Jeremy G. Siek +// +// 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_ADJACENCY_MATRIX_HPP +#define BOOST_ADJACENCY_MATRIX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + namespace detail { + + template + class matrix_edge_desc_impl : public edge_desc_impl + { + typedef edge_desc_impl Base; + public: + matrix_edge_desc_impl() { } + matrix_edge_desc_impl(bool exists, Vertex s, Vertex d, + const void* ep = 0) + : Base(s, d, ep), m_exists(exists) { } + bool exists() const { return m_exists; } + private: + bool m_exists; + }; + + struct does_edge_exist { + template + bool operator()(const Edge& e) const { return e.exists(); } + }; + + template + bool get_edge_exists(const std::pair& stored_edge, int) { + return stored_edge.first; + } + template + void set_edge_exists( + std::pair& stored_edge, + bool flag, + int + ) { + stored_edge.first = flag; + } + + template + bool get_edge_exists(const EdgeProxy& edge_proxy, ...) { + return edge_proxy; + } + template + EdgeProxy& set_edge_exists(EdgeProxy& edge_proxy, bool flag, ...) { + edge_proxy = flag; + return edge_proxy; // just to avoid never used warning + } + + + + template + const EdgeProperty& + get_property(const std::pair& stored_edge) { + return stored_edge.second; + } + template + EdgeProperty& + get_property(std::pair& stored_edge) { + return stored_edge.second; + } + + template + inline void + set_property(std::pair& stored_edge, + const EdgeProperty& ep, int) { + stored_edge.second = ep; + } + + inline const no_property& get_property(const char&) { + static no_property s_prop; + return s_prop; + } + inline no_property& get_property(char&) { + static no_property s_prop; + return s_prop; + } + template + inline void + set_property(EdgeProxy, const EdgeProperty&, ...) {} + + //======================================================================= + // Directed Out Edge Iterator + + template < + typename VertexDescriptor, typename MatrixIter + , typename VerticesSizeType, typename EdgeDescriptor + > + struct dir_adj_matrix_out_edge_iter + : iterator_adaptor< + dir_adj_matrix_out_edge_iter + , MatrixIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , std::ptrdiff_t + > + { + typedef iterator_adaptor< + dir_adj_matrix_out_edge_iter + , MatrixIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , std::ptrdiff_t + > super_t; + + dir_adj_matrix_out_edge_iter() { } + + dir_adj_matrix_out_edge_iter( + const MatrixIter& i + , const VertexDescriptor& src + , const VerticesSizeType& n + ) + : super_t(i), m_src(src), m_targ(0), m_n(n) + { } + + void increment() { + ++this->base_reference(); + ++m_targ; + } + + inline EdgeDescriptor + dereference() const + { + return EdgeDescriptor(get_edge_exists(*this->base(), 0), m_src, m_targ, + &get_property(*this->base())); + } + VertexDescriptor m_src, m_targ; + VerticesSizeType m_n; + }; + + //======================================================================= + // Undirected Out Edge Iterator + + template < + typename VertexDescriptor, typename MatrixIter + , typename VerticesSizeType, typename EdgeDescriptor + > + struct undir_adj_matrix_out_edge_iter + : iterator_adaptor< + undir_adj_matrix_out_edge_iter + , MatrixIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , std::ptrdiff_t + > + { + typedef iterator_adaptor< + undir_adj_matrix_out_edge_iter + , MatrixIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , std::ptrdiff_t + > super_t; + + undir_adj_matrix_out_edge_iter() { } + + undir_adj_matrix_out_edge_iter( + const MatrixIter& i + , const VertexDescriptor& src + , const VerticesSizeType& n + ) + : super_t(i), m_src(src), m_inc(src), m_targ(0), m_n(n) + {} + + void increment() + { + if (m_targ < m_src) // first half + { + ++this->base_reference(); + } + else if (m_targ < m_n - 1) + { // second half + ++m_inc; + this->base_reference() += m_inc; + } + else + { // past-the-end + this->base_reference() += m_n - m_src; + } + ++m_targ; + } + + inline EdgeDescriptor + dereference() const + { + return EdgeDescriptor( + get_edge_exists(*this->base(), 0), m_src, m_targ + , &get_property(*this->base()) + ); + } + + VertexDescriptor m_src, m_inc, m_targ; + VerticesSizeType m_n; + }; + + //======================================================================= + // Edge Iterator + + template + struct adj_matrix_edge_iter + : iterator_adaptor< + adj_matrix_edge_iter + , MatrixIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , std::ptrdiff_t + > + { + typedef iterator_adaptor< + adj_matrix_edge_iter + , MatrixIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , std::ptrdiff_t + > super_t; + + adj_matrix_edge_iter() { } + + adj_matrix_edge_iter(const MatrixIter& i, const MatrixIter& start, const VerticesSizeType& n) + : super_t(i), m_start(start), m_src(0), m_targ(0), m_n(n) { } + + void increment() + { + increment_dispatch(this->base_reference(), Directed()); + } + + void increment_dispatch(MatrixIter& i, directedS) + { + ++i; + if (m_targ == m_n - 1) + { + m_targ = 0; + ++m_src; + } + else + { + ++m_targ; + } + } + + void increment_dispatch(MatrixIter& i, undirectedS) + { + ++i; + if (m_targ == m_src) + { + m_targ = 0; + ++m_src; + } + else + { + ++m_targ; + } + } + + inline EdgeDescriptor + dereference() const + { + return EdgeDescriptor( + get_edge_exists( + *this->base(), 0), m_src, m_targ, &get_property(*this->base()) + ); + } + + MatrixIter m_start; + VerticesSizeType m_src, m_targ, m_n; + }; + + } // namespace detail + + //========================================================================= + // Adjacency Matrix Traits + template + class adjacency_matrix_traits { + typedef typename Directed::is_bidir_t is_bidir; + typedef typename Directed::is_directed_t is_directed; + public: + typedef typename boost::ct_if_t::type + >::type directed_category; + + typedef disallow_parallel_edge_tag edge_parallel_category; + + typedef std::size_t vertex_descriptor; + + typedef detail::matrix_edge_desc_impl edge_descriptor; + }; + + struct adjacency_matrix_class_tag { }; + + struct adj_matrix_traversal_tag : + public virtual adjacency_matrix_tag, + public virtual vertex_list_graph_tag, + public virtual incidence_graph_tag, + public virtual adjacency_graph_tag, + public virtual edge_list_graph_tag { }; + + //========================================================================= + // Adjacency Matrix Class + template > + class adjacency_matrix { + typedef adjacency_matrix self; + typedef adjacency_matrix_traits Traits; + + public: +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + typedef typename detail::retag_property_list::type + vertex_property_type; + typedef typename detail::retag_property_list::type + edge_property_type; + + private: + typedef typename detail::retag_property_list::retagged + maybe_vertex_bundled; + + typedef typename detail::retag_property_list::retagged + maybe_edge_bundled; + + public: + // The types that are actually bundled + typedef typename ct_if<(is_same::value), + no_vertex_bundle, + maybe_vertex_bundled>::type vertex_bundled; + typedef typename ct_if<(is_same::value), + no_edge_bundle, + maybe_edge_bundled>::type edge_bundled; +#else + typedef EdgeProperty edge_property_type; + typedef VertexProperty vertex_property_type; + typedef no_vertex_bundle vertex_bundled; + typedef no_edge_bundle edge_bundled; +#endif + + public: // should be private + typedef typename ct_if_t::type, + std::pair, char>::type StoredEdge; +#if (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || defined(BOOST_NO_STD_ALLOCATOR) + typedef std::vector Matrix; +#else + // This causes internal compiler error for MSVC + typedef typename Allocator::template rebind::other Alloc; + typedef std::vector Matrix; +#endif + typedef typename Matrix::iterator MatrixIter; + typedef typename Matrix::size_type size_type; + public: + // Graph concept required types + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + typedef typename Traits::directed_category directed_category; + typedef typename Traits::edge_parallel_category edge_parallel_category; + typedef adj_matrix_traversal_tag traversal_category; + + static vertex_descriptor null_vertex() + { + return (std::numeric_limits::max)(); + } + + //private: if friends worked, these would be private + + typedef detail::dir_adj_matrix_out_edge_iter< + vertex_descriptor, MatrixIter, size_type, edge_descriptor + > DirOutEdgeIter; + + typedef detail::undir_adj_matrix_out_edge_iter< + vertex_descriptor, MatrixIter, size_type, edge_descriptor + > UnDirOutEdgeIter; + + typedef typename ct_if_t< + typename Directed::is_directed_t, DirOutEdgeIter, UnDirOutEdgeIter + >::type unfiltered_out_edge_iter; + + typedef detail::adj_matrix_edge_iter< + Directed, MatrixIter, size_type, edge_descriptor + > unfiltered_edge_iter; + + public: + + // IncidenceGraph concept required types + typedef filter_iterator + out_edge_iterator; + + typedef size_type degree_size_type; + + // BidirectionalGraph required types + typedef void in_edge_iterator; + + // AdjacencyGraph required types + typedef typename adjacency_iterator_generator::type adjacency_iterator; + + // VertexListGraph required types + typedef size_type vertices_size_type; + typedef integer_range VertexList; + typedef typename VertexList::iterator vertex_iterator; + + // EdgeListGrpah required types + typedef size_type edges_size_type; + typedef filter_iterator< + detail::does_edge_exist, unfiltered_edge_iter + > edge_iterator; + + // PropertyGraph required types + typedef adjacency_matrix_class_tag graph_tag; + + // Constructor required by MutableGraph + adjacency_matrix(vertices_size_type n_vertices) + : m_matrix(Directed::is_directed ? + (n_vertices * n_vertices) + : (n_vertices * (n_vertices + 1) / 2)), + m_vertex_set(0, n_vertices), + m_vertex_properties(n_vertices), + m_num_edges(0) { } + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + // Directly access a vertex or edge bundle + vertex_bundled& operator[](vertex_descriptor v) + { return get(vertex_bundle, *this)[v]; } + + const vertex_bundled& operator[](vertex_descriptor v) const + { return get(vertex_bundle, *this)[v]; } + + edge_bundled& operator[](edge_descriptor e) + { return get(edge_bundle, *this)[e]; } + + const edge_bundled& operator[](edge_descriptor e) const + { return get(edge_bundle, *this)[e]; } +#endif + + //private: if friends worked, these would be private + + typename Matrix::const_reference + get_edge(vertex_descriptor u, vertex_descriptor v) const { + if (Directed::is_directed) + return m_matrix[u * m_vertex_set.size() + v]; + else { + if (v > u) + std::swap(u, v); + return m_matrix[u * (u + 1)/2 + v]; + } + } + typename Matrix::reference + get_edge(vertex_descriptor u, vertex_descriptor v) { + if (Directed::is_directed) + return m_matrix[u * m_vertex_set.size() + v]; + else { + if (v > u) + std::swap(u, v); + return m_matrix[u * (u + 1)/2 + v]; + } + } + + Matrix m_matrix; + VertexList m_vertex_set; + std::vector m_vertex_properties; + size_type m_num_edges; + }; + + //========================================================================= + // Functions required by the AdjacencyMatrix concept + + template + std::pair::edge_descriptor, + bool> + edge(typename adjacency_matrix::vertex_descriptor u, + typename adjacency_matrix::vertex_descriptor v, + const adjacency_matrix& g) + { + bool exists = detail::get_edge_exists(g.get_edge(u,v), 0); + typename adjacency_matrix::edge_descriptor + e(exists, u, v, &detail::get_property(g.get_edge(u,v))); + return std::make_pair(e, exists); + } + + //========================================================================= + // Functions required by the IncidenceGraph concept + + // O(1) + template + std::pair::out_edge_iterator, + typename adjacency_matrix::out_edge_iterator> + out_edges + (typename adjacency_matrix::vertex_descriptor u, + const adjacency_matrix& g_) + { + typedef adjacency_matrix Graph; + Graph& g = const_cast(g_); + typename Graph::vertices_size_type offset = u * g.m_vertex_set.size(); + typename Graph::MatrixIter f = g.m_matrix.begin() + offset; + typename Graph::MatrixIter l = f + g.m_vertex_set.size(); + typename Graph::unfiltered_out_edge_iter + first(f, u, g.m_vertex_set.size()) + , last(l, u, g.m_vertex_set.size()); + detail::does_edge_exist pred; + typedef typename Graph::out_edge_iterator out_edge_iterator; + return std::make_pair(out_edge_iterator(pred, first, last), + out_edge_iterator(pred, last, last)); + } + + // O(1) + template + std::pair< + typename adjacency_matrix::out_edge_iterator, + typename adjacency_matrix::out_edge_iterator> + out_edges + (typename adjacency_matrix::vertex_descriptor u, + const adjacency_matrix& g_) + { + typedef adjacency_matrix Graph; + Graph& g = const_cast(g_); + typename Graph::vertices_size_type offset = u * (u + 1) / 2; + typename Graph::MatrixIter f = g.m_matrix.begin() + offset; + typename Graph::MatrixIter l = g.m_matrix.end(); + + typename Graph::unfiltered_out_edge_iter + first(f, u, g.m_vertex_set.size()) + , last(l, u, g.m_vertex_set.size()); + + detail::does_edge_exist pred; + typedef typename Graph::out_edge_iterator out_edge_iterator; + return std::make_pair(out_edge_iterator(pred, first, last), + out_edge_iterator(pred, last, last)); + } + + // O(N) + template + typename adjacency_matrix::degree_size_type + out_degree(typename adjacency_matrix::vertex_descriptor u, + const adjacency_matrix& g) + { + typename adjacency_matrix::degree_size_type n = 0; + typename adjacency_matrix::out_edge_iterator f, l; + for (tie(f, l) = out_edges(u, g); f != l; ++f) + ++n; + return n; + } + + // O(1) + template + typename adjacency_matrix::vertex_descriptor + source(const detail::matrix_edge_desc_impl& e, + const adjacency_matrix&) + { + return e.m_source; + } + + // O(1) + template + typename adjacency_matrix::vertex_descriptor + target(const detail::matrix_edge_desc_impl& e, + const adjacency_matrix&) + { + return e.m_target; + } + + //========================================================================= + // Functions required by the AdjacencyGraph concept + + template + std::pair::adjacency_iterator, + typename adjacency_matrix::adjacency_iterator> + adjacent_vertices + (typename adjacency_matrix::vertex_descriptor u, + const adjacency_matrix& g_) + { + typedef adjacency_matrix Graph; + const Graph& cg = static_cast(g_); + Graph& g = const_cast(cg); + typedef typename Graph::adjacency_iterator adjacency_iterator; + typename Graph::out_edge_iterator first, last; + boost::tie(first, last) = out_edges(u, g); + return std::make_pair(adjacency_iterator(first, &g), + adjacency_iterator(last, &g)); + } + + //========================================================================= + // Functions required by the VertexListGraph concept + + template + std::pair::vertex_iterator, + typename adjacency_matrix::vertex_iterator> + vertices(const adjacency_matrix& g_) { + typedef adjacency_matrix Graph; + Graph& g = const_cast(g_); + return std::make_pair(g.m_vertex_set.begin(), g.m_vertex_set.end()); + } + + template + typename adjacency_matrix::vertices_size_type + num_vertices(const adjacency_matrix& g) { + return g.m_vertex_set.size(); + } + + //========================================================================= + // Functions required by the EdgeListGraph concept + + template + std::pair::edge_iterator, + typename adjacency_matrix::edge_iterator> + edges(const adjacency_matrix& g_) + { + typedef adjacency_matrix Graph; + Graph& g = const_cast(g_); + + typename Graph::unfiltered_edge_iter + first(g.m_matrix.begin(), g.m_matrix.begin(), + g.m_vertex_set.size()), + last(g.m_matrix.end(), g.m_matrix.begin(), + g.m_vertex_set.size()); + detail::does_edge_exist pred; + typedef typename Graph::edge_iterator edge_iterator; + return std::make_pair(edge_iterator(pred, first, last), + edge_iterator(pred, last, last)); + } + + // O(1) + template + typename adjacency_matrix::edges_size_type + num_edges(const adjacency_matrix& g) + { + return g.m_num_edges; + } + + //========================================================================= + // Functions required by the MutableGraph concept + + // O(1) + template + std::pair::edge_descriptor, bool> + add_edge(typename adjacency_matrix::vertex_descriptor u, + typename adjacency_matrix::vertex_descriptor v, + const EP& ep, + adjacency_matrix& g) + { + typedef typename adjacency_matrix::edge_descriptor + edge_descriptor; + if (detail::get_edge_exists(g.get_edge(u,v), 0) == false) { + ++(g.m_num_edges); + detail::set_property(g.get_edge(u,v), ep, 0); + detail::set_edge_exists(g.get_edge(u,v), true, 0); + return std::make_pair + (edge_descriptor(true, u, v, &detail::get_property(g.get_edge(u,v))), + true); + } else + return std::make_pair + (edge_descriptor(true, u, v, &detail::get_property(g.get_edge(u,v))), + false); + } + // O(1) + template + std::pair::edge_descriptor, bool> + add_edge(typename adjacency_matrix::vertex_descriptor u, + typename adjacency_matrix::vertex_descriptor v, + adjacency_matrix& g) + { + EP ep; + return add_edge(u, v, ep, g); + } + + // O(1) + template + void + remove_edge(typename adjacency_matrix::vertex_descriptor u, + typename adjacency_matrix::vertex_descriptor v, + adjacency_matrix& g) + { + --(g.m_num_edges); + detail::set_edge_exists(g.get_edge(u,v), false, 0); + } + + // O(1) + template + void + remove_edge(typename adjacency_matrix::edge_descriptor e, + adjacency_matrix& g) + { + remove_edge(source(e, g), target(e, g), g); + } + + + template + inline typename adjacency_matrix::vertex_descriptor + add_vertex(adjacency_matrix& g) { + // UNDER CONSTRUCTION + assert(false); + return *vertices(g).first; + } + + template + inline typename adjacency_matrix::vertex_descriptor + add_vertex(const VP& vp, adjacency_matrix& g) { + // UNDER CONSTRUCTION + assert(false); + return *vertices(g).first; + } + + template + inline void + remove_vertex(typename adjacency_matrix::vertex_descriptor u, + adjacency_matrix& g) + { + // UNDER CONSTRUCTION + assert(false); + } + + // O(V) + template + void + clear_vertex + (typename adjacency_matrix::vertex_descriptor u, + adjacency_matrix& g) + { + typename adjacency_matrix::vertex_iterator + vi, vi_end; + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + remove_edge(u, *vi, g); + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + remove_edge(*vi, u, g); + } + + // O(V) + template + void + clear_vertex + (typename adjacency_matrix::vertex_descriptor u, + adjacency_matrix& g) + { + typename adjacency_matrix::vertex_iterator + vi, vi_end; + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + remove_edge(u, *vi, g); + } + + //========================================================================= + // Vertex Property Map + + template + class adj_matrix_vertex_property_map + : public put_get_helper > + { + public: + typedef T value_type; + typedef R reference; + typedef Vertex key_type; + typedef boost::lvalue_property_map_tag category; + adj_matrix_vertex_property_map() { } + adj_matrix_vertex_property_map(GraphPtr g) : m_g(g) { } + inline reference operator[](key_type v) const { + return get_property_value(m_g->m_vertex_properties[v], Tag()); + } + GraphPtr m_g; + }; + + template + struct adj_matrix_vertex_id_map + : public boost::put_get_helper > + { + typedef Vertex value_type; + typedef Vertex reference; + typedef Vertex key_type; + typedef boost::readable_property_map_tag category; + adj_matrix_vertex_id_map() { } + template + inline adj_matrix_vertex_id_map(const Graph&) { } + inline value_type operator[](key_type v) const { return v; } + }; + + namespace detail { + + struct adj_matrix_any_vertex_pa { + template + struct bind_ { + typedef typename property_value::type Value; + typedef typename boost::graph_traits::vertex_descriptor Vertex; + + typedef adj_matrix_vertex_property_map type; + typedef adj_matrix_vertex_property_map const_type; + }; + }; + struct adj_matrix_id_vertex_pa { + template + struct bind_ { + typedef typename Graph::vertex_descriptor Vertex; + typedef adj_matrix_vertex_id_map type; + typedef adj_matrix_vertex_id_map const_type; + }; + }; + + template + struct adj_matrix_choose_vertex_pa_helper { + typedef adj_matrix_any_vertex_pa type; + }; + template <> + struct adj_matrix_choose_vertex_pa_helper { + typedef adj_matrix_id_vertex_pa type; + }; + + template + struct adj_matrix_choose_vertex_pa { + typedef typename adj_matrix_choose_vertex_pa_helper::type Helper; + typedef typename Helper::template bind_ Bind; + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + + struct adj_matrix_vertex_property_selector { + template + struct bind_ { + typedef adj_matrix_choose_vertex_pa Choice; + typedef typename Choice::type type; + typedef typename Choice::const_type const_type; + }; + }; + + } // namespace detail + + template <> + struct vertex_property_selector { + typedef detail::adj_matrix_vertex_property_selector type; + }; + + //========================================================================= + // Edge Property Map + + + template + class adj_matrix_edge_property_map + : public put_get_helper > + { + public: + typedef T value_type; + typedef R reference; + typedef detail::matrix_edge_desc_impl key_type; + typedef boost::lvalue_property_map_tag category; + inline reference operator[](key_type e) const { + Property& p = *(Property*)e.get_property(); + return get_property_value(p, Tag()); + } + }; + struct adj_matrix_edge_property_selector { + template + struct bind_ { + typedef typename property_value::type T; + typedef typename Graph::vertex_descriptor Vertex; + typedef adj_matrix_edge_property_map type; + typedef adj_matrix_edge_property_map const_type; + }; + }; + template <> + struct edge_property_selector { + typedef adj_matrix_edge_property_selector type; + }; + + //========================================================================= + // Functions required by PropertyGraph + + namespace detail { + + template + typename boost::property_map, + Property>::type + get_dispatch(adjacency_matrix& g, Property, + vertex_property_tag) + { + typedef adjacency_matrix Graph; + typedef typename boost::property_map, + Property>::type PA; + return PA(&g); + } + template + typename boost::property_map, + Property>::type + get_dispatch(adjacency_matrix&, Property, + edge_property_tag) + { + typedef typename boost::property_map, + Property>::type PA; + return PA(); + } + template + typename boost::property_map, + Property>::const_type + get_dispatch(const adjacency_matrix& g, Property, + vertex_property_tag) + { + typedef adjacency_matrix Graph; + typedef typename boost::property_map, + Property>::const_type PA; + return PA(&g); + } + template + typename boost::property_map, + Property>::const_type + get_dispatch(const adjacency_matrix&, Property, + edge_property_tag) + { + typedef typename boost::property_map, + Property>::const_type PA; + return PA(); + } + + } // namespace detail + + template + inline + typename property_map, Property>::type + get(Property p, adjacency_matrix& g) + { + typedef typename property_kind::type Kind; + return detail::get_dispatch(g, p, Kind()); + } + + template + inline + typename property_map, Property>::const_type + get(Property p, const adjacency_matrix& g) + { + typedef typename property_kind::type Kind; + return detail::get_dispatch(g, p, Kind()); + } + + template + inline + typename property_traits< + typename property_map, Property>::const_type + >::value_type + get(Property p, const adjacency_matrix& g, + const Key& key) + { + return get(get(p, g), key); + } + + template + inline void + put(Property p, adjacency_matrix& g, + const Key& key, const Value& value) + { + typedef adjacency_matrix Graph; + typedef typename boost::property_map::type Map; + Map pmap = get(p, g); + put(pmap, key, value); + } + + //========================================================================= + // Other Functions + + template + typename adjacency_matrix::vertex_descriptor + vertex(typename adjacency_matrix::vertices_size_type n, + const adjacency_matrix& g) + { + return n; + } + + // Support for bundled properties +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + template + inline + typename property_map, + T Bundle::*>::type + get(T Bundle::* p, adjacency_matrix& g) + { + typedef typename property_map, + T Bundle::*>::type + result_type; + return result_type(&g, p); + } + + template + inline + typename property_map, + T Bundle::*>::const_type + get(T Bundle::* p, adjacency_matrix const & g) + { + typedef typename property_map, + T Bundle::*>::const_type + result_type; + return result_type(&g, p); + } + + template + inline T + get(T Bundle::* p, adjacency_matrix const & g, + const Key& key) + { + return get(get(p, g), key); + } + + template + inline void + put(T Bundle::* p, adjacency_matrix& g, + const Key& key, const T& value) + { + put(get(p, g), key, value); + } + +#endif + +} // namespace boost + +#endif // BOOST_ADJACENCY_MATRIX_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/astar_search.hpp b/deal.II/contrib/boost/include/boost/graph/astar_search.hpp new file mode 100644 index 0000000000..8dbdd3a03d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/astar_search.hpp @@ -0,0 +1,390 @@ + + +// +//======================================================================= +// Copyright (c) 2004 Kristopher Beevers +// +// 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_GRAPH_ASTAR_SEARCH_HPP +#define BOOST_GRAPH_ASTAR_SEARCH_HPP + + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace boost { + + + template + struct AStarHeuristicConcept { + void constraints() + { + function_requires< CopyConstructibleConcept >(); + h(u); + } + Heuristic h; + typename graph_traits::vertex_descriptor u; + }; + + + template + class astar_heuristic : public std::unary_function< + typename graph_traits::vertex_descriptor, CostType> + { + public: + typedef typename graph_traits::vertex_descriptor Vertex; + astar_heuristic() {} + CostType operator()(Vertex u) { return static_cast(0); } + }; + + + + template + struct AStarVisitorConcept { + void constraints() + { + function_requires< CopyConstructibleConcept >(); + vis.initialize_vertex(u, g); + vis.discover_vertex(u, g); + vis.examine_vertex(u, g); + vis.examine_edge(e, g); + vis.edge_relaxed(e, g); + vis.edge_not_relaxed(e, g); + vis.black_target(e, g); + vis.finish_vertex(u, g); + } + Visitor vis; + Graph g; + typename graph_traits::vertex_descriptor u; + typename graph_traits::edge_descriptor e; + }; + + + template + class astar_visitor : public bfs_visitor { + public: + astar_visitor() {} + astar_visitor(Visitors vis) + : bfs_visitor(vis) {} + + template + void edge_relaxed(Edge e, Graph& g) { + invoke_visitors(this->m_vis, e, g, on_edge_relaxed()); + } + template + void edge_not_relaxed(Edge e, Graph& g) { + invoke_visitors(this->m_vis, e, g, on_edge_not_relaxed()); + } + private: + template + void tree_edge(Edge e, Graph& g) {} + template + void non_tree_edge(Edge e, Graph& g) {} + }; + template + astar_visitor + make_astar_visitor(Visitors vis) { + return astar_visitor(vis); + } + typedef astar_visitor<> default_astar_visitor; + + + namespace detail { + + template + struct astar_bfs_visitor + { + + typedef typename property_traits::value_type C; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + + astar_bfs_visitor(AStarHeuristic h, UniformCostVisitor vis, + UpdatableQueue& Q, PredecessorMap p, + CostMap c, DistanceMap d, WeightMap w, + ColorMap col, BinaryFunction combine, + BinaryPredicate compare, C zero) + : m_h(h), m_vis(vis), m_Q(Q), m_predecessor(p), m_cost(c), + m_distance(d), m_weight(w), m_color(col), + m_combine(combine), m_compare(compare), m_zero(zero) {} + + + template + void initialize_vertex(Vertex u, Graph& g) { + m_vis.initialize_vertex(u, g); + } + template + void discover_vertex(Vertex u, Graph& g) { + m_vis.discover_vertex(u, g); + } + template + void examine_vertex(Vertex u, Graph& g) { + m_vis.examine_vertex(u, g); + } + template + void finish_vertex(Vertex u, Graph& g) { + m_vis.finish_vertex(u, g); + } + template + void examine_edge(Edge e, Graph& g) { + if (m_compare(get(m_weight, e), m_zero)) + throw negative_edge(); + m_vis.examine_edge(e, g); + } + template + void non_tree_edge(Edge, Graph&) {} + + + + template + void tree_edge(Edge e, Graph& g) { + m_decreased = relax(e, g, m_weight, m_predecessor, m_distance, + m_combine, m_compare); + if(m_decreased) { + m_vis.edge_relaxed(e, g); + put(m_cost, target(e, g), + m_combine(get(m_distance, target(e, g)), + m_h(target(e, g)))); + } else + m_vis.edge_not_relaxed(e, g); + } + + + template + void gray_target(Edge e, Graph& g) { + m_decreased = relax(e, g, m_weight, m_predecessor, m_distance, + m_combine, m_compare); + if(m_decreased) { + put(m_cost, target(e, g), + m_combine(get(m_distance, target(e, g)), + m_h(target(e, g)))); + m_Q.update(target(e, g)); + m_vis.edge_relaxed(e, g); + } else + m_vis.edge_not_relaxed(e, g); + } + + + template + void black_target(Edge e, Graph& g) { + m_decreased = relax(e, g, m_weight, m_predecessor, m_distance, + m_combine, m_compare); + if(m_decreased) { + m_vis.edge_relaxed(e, g); + put(m_cost, target(e, g), + m_combine(get(m_distance, target(e, g)), + m_h(target(e, g)))); + m_Q.push(target(e, g)); + put(m_color, target(e, g), Color::gray()); + m_vis.black_target(e, g); + } else + m_vis.edge_not_relaxed(e, g); + } + + + + AStarHeuristic m_h; + UniformCostVisitor m_vis; + UpdatableQueue& m_Q; + PredecessorMap m_predecessor; + CostMap m_cost; + DistanceMap m_distance; + WeightMap m_weight; + ColorMap m_color; + BinaryFunction m_combine; + BinaryPredicate m_compare; + bool m_decreased; + C m_zero; + + }; + + } // namespace detail + + + + template + inline void + astar_search_no_init + (VertexListGraph &g, + typename graph_traits::vertex_descriptor s, + AStarHeuristic h, AStarVisitor vis, + PredecessorMap predecessor, CostMap cost, + DistanceMap distance, WeightMap weight, + ColorMap color, VertexIndexMap index_map, + CompareFunction compare, CombineFunction combine, + CostInf inf, CostZero zero) + { + typedef indirect_cmp IndirectCmp; + IndirectCmp icmp(cost, compare); + + typedef typename graph_traits::vertex_descriptor + Vertex; + typedef mutable_queue, + IndirectCmp, VertexIndexMap> + MutableQueue; + MutableQueue Q(num_vertices(g), icmp, index_map); + + detail::astar_bfs_visitor + bfs_vis(h, vis, Q, predecessor, cost, distance, weight, + color, combine, compare, zero); + + breadth_first_visit(g, s, Q, bfs_vis, color); + } + + + // Non-named parameter interface + template + inline void + astar_search + (VertexListGraph &g, + typename graph_traits::vertex_descriptor s, + AStarHeuristic h, AStarVisitor vis, + PredecessorMap predecessor, CostMap cost, + DistanceMap distance, WeightMap weight, + VertexIndexMap index_map, ColorMap color, + CompareFunction compare, CombineFunction combine, + CostInf inf, CostZero zero) + { + + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + put(color, *ui, Color::white()); + put(distance, *ui, inf); + put(cost, *ui, inf); + put(predecessor, *ui, *ui); + } + put(distance, s, zero); + put(cost, s, h(s)); + + astar_search_no_init + (g, s, h, vis, predecessor, cost, distance, weight, + color, index_map, compare, combine, inf, zero); + + } + + + + namespace detail { + template + inline void + astar_dispatch2 + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + AStarHeuristic h, CostMap cost, DistanceMap distance, + WeightMap weight, IndexMap index_map, ColorMap color, + const Params& params) + { + dummy_property_map p_map; + typedef typename property_traits::value_type C; + astar_search + (g, s, h, + choose_param(get_param(params, graph_visitor), + make_astar_visitor(null_visitor())), + choose_param(get_param(params, vertex_predecessor), p_map), + cost, distance, weight, index_map, color, + choose_param(get_param(params, distance_compare_t()), + std::less()), + choose_param(get_param(params, distance_combine_t()), + closed_plus()), + choose_param(get_param(params, distance_inf_t()), + std::numeric_limits::max BOOST_PREVENT_MACRO_SUBSTITUTION ()), + choose_param(get_param(params, distance_zero_t()), + C())); + } + + template + inline void + astar_dispatch1 + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + AStarHeuristic h, CostMap cost, DistanceMap distance, + WeightMap weight, IndexMap index_map, ColorMap color, + const Params& params) + { + typedef typename property_traits::value_type D; + typename std::vector::size_type + n = is_default_param(distance) ? num_vertices(g) : 1; + std::vector distance_map(n); + n = is_default_param(cost) ? num_vertices(g) : 1; + std::vector cost_map(n); + std::vector color_map(num_vertices(g)); + default_color_type c = white_color; + + detail::astar_dispatch2 + (g, s, h, + choose_param(cost, make_iterator_property_map + (cost_map.begin(), index_map, + cost_map[0])), + choose_param(distance, make_iterator_property_map + (distance_map.begin(), index_map, + distance_map[0])), + weight, index_map, + choose_param(color, make_iterator_property_map + (color_map.begin(), index_map, c)), + params); + } + } // namespace detail + + + // Named parameter interface + template + void + astar_search + (VertexListGraph &g, + typename graph_traits::vertex_descriptor s, + AStarHeuristic h, const bgl_named_params& params) + { + + detail::astar_dispatch1 + (g, s, h, + get_param(params, vertex_rank), + get_param(params, vertex_distance), + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index), + get_param(params, vertex_color), + params); + + } + +} // namespace boost + +#endif // BOOST_GRAPH_ASTAR_SEARCH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/bandwidth.hpp b/deal.II/contrib/boost/include/boost/graph/bandwidth.hpp new file mode 100644 index 0000000000..ea44b31791 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/bandwidth.hpp @@ -0,0 +1,83 @@ +// Copyright (c) Jeremy Siek 2001, Marc Wintermantel 2002 +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_GRAPH_BANDWIDTH_HPP +#define BOOST_GRAPH_BANDWIDTH_HPP + +#include // for std::min and std::max +#include +#include +#include + +namespace boost { + + template + typename graph_traits::vertices_size_type + ith_bandwidth(typename graph_traits::vertex_descriptor i, + const Graph& g, + VertexIndexMap index) + { + BOOST_USING_STD_MAX(); + typedef typename graph_traits::vertices_size_type size_type; + size_type b = 0; + typename graph_traits::out_edge_iterator e, end; + for (tie(e, end) = out_edges(i, g); e != end; ++e) { + int f_i = get(index, i); + int f_j = get(index, target(*e, g)); + using namespace std; // to call abs() unqualified + if(f_i > f_j) + b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, size_type(f_i - f_j)); + } + return b; + } + + template + typename graph_traits::vertices_size_type + ith_bandwidth(typename graph_traits::vertex_descriptor i, + const Graph& g) + { + return ith_bandwidth(i, g, get(vertex_index, g)); + } + + template + typename graph_traits::vertices_size_type + bandwidth(const Graph& g, VertexIndexMap index) + { + BOOST_USING_STD_MAX(); + typename graph_traits::vertices_size_type b = 0; + typename graph_traits::vertex_iterator i, end; + for (tie(i, end) = vertices(g); i != end; ++i) + b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, ith_bandwidth(*i, g, index)); + return b; + } + + template + typename graph_traits::vertices_size_type + bandwidth(const Graph& g) + { + return bandwidth(g, get(vertex_index, g)); + } + + template + typename graph_traits::vertices_size_type + edgesum(const Graph& g, VertexIndexMap index_map) + { + typedef typename graph_traits::vertices_size_type size_type; + typedef typename detail::numeric_traits::difference_type diff_t; + size_type sum = 0; + typename graph_traits::edge_iterator i, end; + for (tie(i, end) = edges(g); i != end; ++i) { + diff_t f_u = get(index_map, source(*i, g)); + diff_t f_v = get(index_map, target(*i, g)); + using namespace std; // to call abs() unqualified + sum += abs(f_u - f_v); + } + return sum; + } + +} // namespace boost + +#endif // BOOST_GRAPH_BANDWIDTH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/bc_clustering.hpp b/deal.II/contrib/boost/include/boost/graph/bc_clustering.hpp new file mode 100644 index 0000000000..c412ff5f57 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/bc_clustering.hpp @@ -0,0 +1,164 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_BETWEENNESS_CENTRALITY_CLUSTERING_HPP +#define BOOST_GRAPH_BETWEENNESS_CENTRALITY_CLUSTERING_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + +/** Threshold termination function for the betweenness centrality + * clustering algorithm. + */ +template +struct bc_clustering_threshold +{ + typedef T centrality_type; + + /// Terminate clustering when maximum absolute edge centrality is + /// below the given threshold. + explicit bc_clustering_threshold(T threshold) + : threshold(threshold), dividend(1.0) {} + + /** + * Terminate clustering when the maximum edge centrality is below + * the given threshold. + * + * @param threshold the threshold value + * + * @param g the graph on which the threshold will be calculated + * + * @param normalize when true, the threshold is compared against the + * normalized edge centrality based on the input graph; otherwise, + * the threshold is compared against the absolute edge centrality. + */ + template + bc_clustering_threshold(T threshold, const Graph& g, bool normalize = true) + : threshold(threshold), dividend(1.0) + { + if (normalize) { + typename graph_traits::vertices_size_type n = num_vertices(g); + dividend = T((n - 1) * (n - 2)) / T(2); + } + } + + /** Returns true when the given maximum edge centrality (potentially + * normalized) falls below the threshold. + */ + template + bool operator()(T max_centrality, Edge, const Graph&) + { + return (max_centrality / dividend) < threshold; + } + + protected: + T threshold; + T dividend; +}; + +/** Graph clustering based on edge betweenness centrality. + * + * This algorithm implements graph clustering based on edge + * betweenness centrality. It is an iterative algorithm, where in each + * step it compute the edge betweenness centrality (via @ref + * brandes_betweenness_centrality) and removes the edge with the + * maximum betweenness centrality. The @p done function object + * determines when the algorithm terminates (the edge found when the + * algorithm terminates will not be removed). + * + * @param g The graph on which clustering will be performed. The type + * of this parameter (@c MutableGraph) must be a model of the + * VertexListGraph, IncidenceGraph, EdgeListGraph, and Mutable Graph + * concepts. + * + * @param done The function object that indicates termination of the + * algorithm. It must be a ternary function object thats accepts the + * maximum centrality, the descriptor of the edge that will be + * removed, and the graph @p g. + * + * @param edge_centrality (UTIL/OUT) The property map that will store + * the betweenness centrality for each edge. When the algorithm + * terminates, it will contain the edge centralities for the + * graph. The type of this property map must model the + * ReadWritePropertyMap concept. Defaults to an @c + * iterator_property_map whose value type is + * @c Done::centrality_type and using @c get(edge_index, g) for the + * index map. + * + * @param vertex_index (IN) The property map that maps vertices to + * indices in the range @c [0, num_vertices(g)). This type of this + * property map must model the ReadablePropertyMap concept and its + * value type must be an integral type. Defaults to + * @c get(vertex_index, g). + */ +template +void +betweenness_centrality_clustering(MutableGraph& g, Done done, + EdgeCentralityMap edge_centrality, + VertexIndexMap vertex_index) +{ + typedef typename property_traits::value_type + centrality_type; + typedef typename graph_traits::edge_iterator edge_iterator; + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename graph_traits::vertices_size_type + vertices_size_type; + + if (edges(g).first == edges(g).second) return; + + // Function object that compares the centrality of edges + indirect_cmp > + cmp(edge_centrality); + + bool is_done; + do { + brandes_betweenness_centrality(g, + edge_centrality_map(edge_centrality) + .vertex_index_map(vertex_index)); + edge_descriptor e = *max_element(edges(g).first, edges(g).second, cmp); + is_done = done(get(edge_centrality, e), e, g); + if (!is_done) remove_edge(e, g); + } while (!is_done && edges(g).first != edges(g).second); +} + +/** + * \overload + */ +template +void +betweenness_centrality_clustering(MutableGraph& g, Done done, + EdgeCentralityMap edge_centrality) +{ + betweenness_centrality_clustering(g, done, edge_centrality, + get(vertex_index, g)); +} + +/** + * \overload + */ +template +void +betweenness_centrality_clustering(MutableGraph& g, Done done) +{ + typedef typename Done::centrality_type centrality_type; + std::vector edge_centrality(num_edges(g)); + betweenness_centrality_clustering(g, done, + make_iterator_property_map(edge_centrality.begin(), get(edge_index, g)), + get(vertex_index, g)); +} + +} // end namespace boost + +#endif // BOOST_GRAPH_BETWEENNESS_CENTRALITY_CLUSTERING_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/bellman_ford_shortest_paths.hpp b/deal.II/contrib/boost/include/boost/graph/bellman_ford_shortest_paths.hpp new file mode 100644 index 0000000000..4001c288e7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/bellman_ford_shortest_paths.hpp @@ -0,0 +1,241 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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) +//======================================================================= +// + +/* + This file implements the function + + template + bool bellman_ford_shortest_paths(EdgeListGraph& g, Size N, + const bgl_named_params& params) + + */ + + +#ifndef BOOST_GRAPH_BELLMAN_FORD_SHORTEST_PATHS_HPP +#define BOOST_GRAPH_BELLMAN_FORD_SHORTEST_PATHS_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + struct BellmanFordVisitorConcept { + void constraints() { + function_requires< CopyConstructibleConcept >(); + vis.examine_edge(e, g); + vis.edge_relaxed(e, g); + vis.edge_not_relaxed(e, g); + vis.edge_minimized(e, g); + vis.edge_not_minimized(e, g); + } + Visitor vis; + Graph g; + typename graph_traits::edge_descriptor e; + }; + + template + class bellman_visitor { + public: + bellman_visitor() { } + bellman_visitor(Visitors vis) : m_vis(vis) { } + + template + void examine_edge(Edge u, Graph& g) { + invoke_visitors(m_vis, u, g, on_examine_edge()); + } + template + void edge_relaxed(Edge u, Graph& g) { + invoke_visitors(m_vis, u, g, on_edge_relaxed()); + } + template + void edge_not_relaxed(Edge u, Graph& g) { + invoke_visitors(m_vis, u, g, on_edge_not_relaxed()); + } + template + void edge_minimized(Edge u, Graph& g) { + invoke_visitors(m_vis, u, g, on_edge_minimized()); + } + template + void edge_not_minimized(Edge u, Graph& g) { + invoke_visitors(m_vis, u, g, on_edge_not_minimized()); + } + protected: + Visitors m_vis; + }; + template + bellman_visitor + make_bellman_visitor(Visitors vis) { + return bellman_visitor(vis); + } + typedef bellman_visitor<> default_bellman_visitor; + + template + bool bellman_ford_shortest_paths(EdgeListGraph& g, Size N, + WeightMap weight, + PredecessorMap pred, + DistanceMap distance, + BinaryFunction combine, + BinaryPredicate compare, + BellmanFordVisitor v) + { + function_requires >(); + typedef graph_traits GTraits; + typedef typename GTraits::edge_descriptor Edge; + typedef typename GTraits::vertex_descriptor Vertex; + function_requires >(); + function_requires >(); + typedef typename property_traits::value_type D_value; + typedef typename property_traits::value_type W_value; + + typename GTraits::edge_iterator i, end; + + for (Size k = 0; k < N; ++k) { + bool at_least_one_edge_relaxed = false; + for (tie(i, end) = edges(g); i != end; ++i) { + v.examine_edge(*i, g); + if (relax(*i, g, weight, pred, distance, combine, compare)) { + at_least_one_edge_relaxed = true; + v.edge_relaxed(*i, g); + } else + v.edge_not_relaxed(*i, g); + } + if (!at_least_one_edge_relaxed) + break; + } + + for (tie(i, end) = edges(g); i != end; ++i) + if (compare(combine(get(distance, source(*i, g)), get(weight, *i)), + get(distance, target(*i,g)))) + { + v.edge_not_minimized(*i, g); + return false; + } else + v.edge_minimized(*i, g); + + return true; + } + + namespace detail { + + template + bool + bellman_dispatch2 + (VertexAndEdgeListGraph& g, + typename graph_traits::vertex_descriptor s, + Size N, WeightMap weight, PredecessorMap pred, DistanceMap distance, + const bgl_named_params& params) + { + typedef typename property_traits::value_type D; + bellman_visitor<> null_vis; + typedef typename property_traits::value_type weight_type; + typename graph_traits::vertex_iterator v, v_end; + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + put(distance, *v, (std::numeric_limits::max)()); + put(pred, *v, *v); + } + put(distance, s, weight_type(0)); + return bellman_ford_shortest_paths + (g, N, weight, pred, distance, + choose_param(get_param(params, distance_combine_t()), + closed_plus()), + choose_param(get_param(params, distance_compare_t()), + std::less()), + choose_param(get_param(params, graph_visitor), + null_vis) + ); + } + + template + bool + bellman_dispatch2 + (VertexAndEdgeListGraph& g, + detail::error_property_not_found, + Size N, WeightMap weight, PredecessorMap pred, DistanceMap distance, + const bgl_named_params& params) + { + typedef typename property_traits::value_type D; + bellman_visitor<> null_vis; + return bellman_ford_shortest_paths + (g, N, weight, pred, distance, + choose_param(get_param(params, distance_combine_t()), + closed_plus()), + choose_param(get_param(params, distance_compare_t()), + std::less()), + choose_param(get_param(params, graph_visitor), + null_vis) + ); + } + + template + bool bellman_dispatch(EdgeListGraph& g, Size N, + WeightMap weight, DistanceMap distance, + const bgl_named_params& params) + { + dummy_property_map dummy_pred; + return + detail::bellman_dispatch2 + (g, + get_param(params, root_vertex_t()), + N, weight, + choose_param(get_param(params, vertex_predecessor), dummy_pred), + distance, + params); + } + } // namespace detail + + template + bool bellman_ford_shortest_paths + (EdgeListGraph& g, Size N, + const bgl_named_params& params) + { + return detail::bellman_dispatch + (g, N, + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + choose_pmap(get_param(params, vertex_distance), g, vertex_distance), + params); + } + + template + bool bellman_ford_shortest_paths(EdgeListGraph& g, Size N) + { + bgl_named_params params(0); + return bellman_ford_shortest_paths(g, N, params); + } + + template + bool bellman_ford_shortest_paths + (VertexAndEdgeListGraph& g, + const bgl_named_params& params) + { + function_requires >(); + return detail::bellman_dispatch + (g, num_vertices(g), + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + choose_pmap(get_param(params, vertex_distance), g, vertex_distance), + params); + } +} // namespace boost + +#endif // BOOST_GRAPH_BELLMAN_FORD_SHORTEST_PATHS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/betweenness_centrality.hpp b/deal.II/contrib/boost/include/boost/graph/betweenness_centrality.hpp new file mode 100644 index 0000000000..538026347a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/betweenness_centrality.hpp @@ -0,0 +1,599 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_BRANDES_BETWEENNESS_CENTRALITY_HPP +#define BOOST_GRAPH_BRANDES_BETWEENNESS_CENTRALITY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + +namespace detail { namespace graph { + + /** + * Customized visitor passed to Dijkstra's algorithm by Brandes' + * betweenness centrality algorithm. This visitor is responsible for + * keeping track of the order in which vertices are discovered, the + * predecessors on the shortest path(s) to a vertex, and the number + * of shortest paths. + */ + template + struct brandes_dijkstra_visitor : public bfs_visitor<> + { + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef typename graph_traits::edge_descriptor edge_descriptor; + + brandes_dijkstra_visitor(std::stack& ordered_vertices, + WeightMap weight, + IncomingMap incoming, + DistanceMap distance, + PathCountMap path_count) + : ordered_vertices(ordered_vertices), weight(weight), + incoming(incoming), distance(distance), + path_count(path_count) + { } + + /** + * Whenever an edge e = (v, w) is relaxed, the incoming edge list + * for w is set to {(v, w)} and the shortest path count of w is set to + * the number of paths that reach {v}. + */ + void edge_relaxed(edge_descriptor e, const Graph& g) + { + vertex_descriptor v = source(e, g), w = target(e, g); + incoming[w].clear(); + incoming[w].push_back(e); + put(path_count, w, get(path_count, v)); + } + + /** + * If an edge e = (v, w) was not relaxed, it may still be the case + * that we've found more equally-short paths, so include {(v, w)} in the + * incoming edges of w and add all of the shortest paths to v to the + * shortest path count of w. + */ + void edge_not_relaxed(edge_descriptor e, const Graph& g) + { + typedef typename property_traits::value_type weight_type; + typedef typename property_traits::value_type distance_type; + vertex_descriptor v = source(e, g), w = target(e, g); + distance_type d_v = get(distance, v), d_w = get(distance, w); + weight_type w_e = get(weight, e); + + closed_plus combine; + if (d_w == combine(d_v, w_e)) { + put(path_count, w, get(path_count, w) + get(path_count, v)); + incoming[w].push_back(e); + } + } + + /// Keep track of vertices as they are reached + void examine_vertex(vertex_descriptor w, const Graph&) + { + ordered_vertices.push(w); + } + + private: + std::stack& ordered_vertices; + WeightMap weight; + IncomingMap incoming; + DistanceMap distance; + PathCountMap path_count; + }; + + /** + * Function object that calls Dijkstra's shortest paths algorithm + * using the Dijkstra visitor for the Brandes betweenness centrality + * algorithm. + */ + template + struct brandes_dijkstra_shortest_paths + { + brandes_dijkstra_shortest_paths(WeightMap weight_map) + : weight_map(weight_map) { } + + template + void + operator()(Graph& g, + typename graph_traits::vertex_descriptor s, + std::stack::vertex_descriptor>& ov, + IncomingMap incoming, + DistanceMap distance, + PathCountMap path_count, + VertexIndexMap vertex_index) + { + typedef brandes_dijkstra_visitor visitor_type; + visitor_type visitor(ov, weight_map, incoming, distance, path_count); + + dijkstra_shortest_paths(g, s, + boost::weight_map(weight_map) + .vertex_index_map(vertex_index) + .distance_map(distance) + .visitor(visitor)); + } + + private: + WeightMap weight_map; + }; + + /** + * Function object that invokes breadth-first search for the + * unweighted form of the Brandes betweenness centrality algorithm. + */ + struct brandes_unweighted_shortest_paths + { + /** + * Customized visitor passed to breadth-first search, which + * records predecessor and the number of shortest paths to each + * vertex. + */ + template + struct visitor_type : public bfs_visitor<> + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + + visitor_type(IncomingMap incoming, DistanceMap distance, + PathCountMap path_count, + std::stack& ordered_vertices) + : incoming(incoming), distance(distance), + path_count(path_count), ordered_vertices(ordered_vertices) { } + + /// Keep track of vertices as they are reached + void examine_vertex(vertex_descriptor v, Graph&) + { + ordered_vertices.push(v); + } + + /** + * Whenever an edge e = (v, w) is labelled a tree edge, the + * incoming edge list for w is set to {(v, w)} and the shortest + * path count of w is set to the number of paths that reach {v}. + */ + void tree_edge(edge_descriptor e, Graph& g) + { + vertex_descriptor v = source(e, g); + vertex_descriptor w = target(e, g); + put(distance, w, get(distance, v) + 1); + + put(path_count, w, get(path_count, v)); + incoming[w].push_back(e); + } + + /** + * If an edge e = (v, w) is not a tree edge, it may still be the + * case that we've found more equally-short paths, so include (v, w) + * in the incoming edge list of w and add all of the shortest + * paths to v to the shortest path count of w. + */ + void non_tree_edge(edge_descriptor e, Graph& g) + { + vertex_descriptor v = source(e, g); + vertex_descriptor w = target(e, g); + if (get(distance, w) == get(distance, v) + 1) { + put(path_count, w, get(path_count, w) + get(path_count, v)); + incoming[w].push_back(e); + } + } + + private: + IncomingMap incoming; + DistanceMap distance; + PathCountMap path_count; + std::stack& ordered_vertices; + }; + + template + void + operator()(Graph& g, + typename graph_traits::vertex_descriptor s, + std::stack::vertex_descriptor>& ov, + IncomingMap incoming, + DistanceMap distance, + PathCountMap path_count, + VertexIndexMap vertex_index) + { + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + + visitor_type + visitor(incoming, distance, path_count, ov); + + std::vector + colors(num_vertices(g), color_traits::white()); + boost::queue Q; + breadth_first_visit(g, s, Q, visitor, + make_iterator_property_map(colors.begin(), + vertex_index)); + } + }; + + // When the edge centrality map is a dummy property map, no + // initialization is needed. + template + inline void + init_centrality_map(std::pair, dummy_property_map) { } + + // When we have a real edge centrality map, initialize all of the + // centralities to zero. + template + void + init_centrality_map(std::pair keys, Centrality centrality_map) + { + typedef typename property_traits::value_type + centrality_type; + while (keys.first != keys.second) { + put(centrality_map, *keys.first, centrality_type(0)); + ++keys.first; + } + } + + // When the edge centrality map is a dummy property map, no update + // is performed. + template + inline void + update_centrality(dummy_property_map, const Key&, const T&) { } + + // When we have a real edge centrality map, add the value to the map + template + inline void + update_centrality(CentralityMap centrality_map, Key k, const T& x) + { put(centrality_map, k, get(centrality_map, k) + x); } + + template + inline void + divide_centrality_by_two(std::pair, dummy_property_map) {} + + template + inline void + divide_centrality_by_two(std::pair keys, + CentralityMap centrality_map) + { + typename property_traits::value_type two(2); + while (keys.first != keys.second) { + put(centrality_map, *keys.first, get(centrality_map, *keys.first) / two); + ++keys.first; + } + } + + template + void + brandes_betweenness_centrality_impl(const Graph& g, + CentralityMap centrality, // C_B + EdgeCentralityMap edge_centrality_map, + IncomingMap incoming, // P + DistanceMap distance, // d + DependencyMap dependency, // delta + PathCountMap path_count, // sigma + VertexIndexMap vertex_index, + ShortestPaths shortest_paths) + { + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename graph_traits::edge_iterator edge_iterator; + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + + // Initialize centrality + init_centrality_map(vertices(g), centrality); + init_centrality_map(edges(g), edge_centrality_map); + + std::stack ordered_vertices; + vertex_iterator s, s_end; + for (tie(s, s_end) = vertices(g); s != s_end; ++s) { + // Initialize for this iteration + vertex_iterator w, w_end; + for (tie(w, w_end) = vertices(g); w != w_end; ++w) { + incoming[*w].clear(); + put(path_count, *w, 0); + put(dependency, *w, 0); + } + put(path_count, *s, 1); + + // Execute the shortest paths algorithm. This will be either + // Dijkstra's algorithm or a customized breadth-first search, + // depending on whether the graph is weighted or unweighted. + shortest_paths(g, *s, ordered_vertices, incoming, distance, + path_count, vertex_index); + + while (!ordered_vertices.empty()) { + vertex_descriptor w = ordered_vertices.top(); + ordered_vertices.pop(); + + typedef typename property_traits::value_type + incoming_type; + typedef typename incoming_type::iterator incoming_iterator; + typedef typename property_traits::value_type + dependency_type; + + for (incoming_iterator vw = incoming[w].begin(); + vw != incoming[w].end(); ++vw) { + vertex_descriptor v = source(*vw, g); + dependency_type factor = dependency_type(get(path_count, v)) + / dependency_type(get(path_count, w)); + factor *= (dependency_type(1) + get(dependency, w)); + put(dependency, v, get(dependency, v) + factor); + update_centrality(edge_centrality_map, *vw, factor); + } + + if (w != *s) { + update_centrality(centrality, w, get(dependency, w)); + } + } + } + + typedef typename graph_traits::directed_category directed_category; + const bool is_undirected = + is_convertible::value; + if (is_undirected) { + divide_centrality_by_two(vertices(g), centrality); + divide_centrality_by_two(edges(g), edge_centrality_map); + } + } + +} } // end namespace detail::graph + +template +void +brandes_betweenness_centrality(const Graph& g, + CentralityMap centrality, // C_B + EdgeCentralityMap edge_centrality_map, + IncomingMap incoming, // P + DistanceMap distance, // d + DependencyMap dependency, // delta + PathCountMap path_count, // sigma + VertexIndexMap vertex_index) +{ + detail::graph::brandes_unweighted_shortest_paths shortest_paths; + + detail::graph::brandes_betweenness_centrality_impl(g, centrality, + edge_centrality_map, + incoming, distance, + dependency, path_count, + vertex_index, + shortest_paths); +} + +template +void +brandes_betweenness_centrality(const Graph& g, + CentralityMap centrality, // C_B + EdgeCentralityMap edge_centrality_map, + IncomingMap incoming, // P + DistanceMap distance, // d + DependencyMap dependency, // delta + PathCountMap path_count, // sigma + VertexIndexMap vertex_index, + WeightMap weight_map) +{ + detail::graph::brandes_dijkstra_shortest_paths + shortest_paths(weight_map); + + detail::graph::brandes_betweenness_centrality_impl(g, centrality, + edge_centrality_map, + incoming, distance, + dependency, path_count, + vertex_index, + shortest_paths); +} + +namespace detail { namespace graph { + template + void + brandes_betweenness_centrality_dispatch2(const Graph& g, + CentralityMap centrality, + EdgeCentralityMap edge_centrality_map, + WeightMap weight_map, + VertexIndexMap vertex_index) + { + typedef typename graph_traits::degree_size_type degree_size_type; + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename mpl::if_c<(is_same::value), + EdgeCentralityMap, + CentralityMap>::type a_centrality_map; + typedef typename property_traits::value_type + centrality_type; + + typename graph_traits::vertices_size_type V = num_vertices(g); + + std::vector > incoming(V); + std::vector distance(V); + std::vector dependency(V); + std::vector path_count(V); + + brandes_betweenness_centrality( + g, centrality, edge_centrality_map, + make_iterator_property_map(incoming.begin(), vertex_index), + make_iterator_property_map(distance.begin(), vertex_index), + make_iterator_property_map(dependency.begin(), vertex_index), + make_iterator_property_map(path_count.begin(), vertex_index), + vertex_index, + weight_map); + } + + + template + void + brandes_betweenness_centrality_dispatch2(const Graph& g, + CentralityMap centrality, + EdgeCentralityMap edge_centrality_map, + VertexIndexMap vertex_index) + { + typedef typename graph_traits::degree_size_type degree_size_type; + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename mpl::if_c<(is_same::value), + EdgeCentralityMap, + CentralityMap>::type a_centrality_map; + typedef typename property_traits::value_type + centrality_type; + + typename graph_traits::vertices_size_type V = num_vertices(g); + + std::vector > incoming(V); + std::vector distance(V); + std::vector dependency(V); + std::vector path_count(V); + + brandes_betweenness_centrality( + g, centrality, edge_centrality_map, + make_iterator_property_map(incoming.begin(), vertex_index), + make_iterator_property_map(distance.begin(), vertex_index), + make_iterator_property_map(dependency.begin(), vertex_index), + make_iterator_property_map(path_count.begin(), vertex_index), + vertex_index); + } + + template + struct brandes_betweenness_centrality_dispatch1 + { + template + static void + run(const Graph& g, CentralityMap centrality, + EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index, + WeightMap weight_map) + { + brandes_betweenness_centrality_dispatch2(g, centrality, edge_centrality_map, + weight_map, vertex_index); + } + }; + + template<> + struct brandes_betweenness_centrality_dispatch1 + { + template + static void + run(const Graph& g, CentralityMap centrality, + EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index, + error_property_not_found) + { + brandes_betweenness_centrality_dispatch2(g, centrality, edge_centrality_map, + vertex_index); + } + }; + +} } // end namespace detail::graph + +template +void +brandes_betweenness_centrality(const Graph& g, + const bgl_named_params& params) +{ + typedef bgl_named_params named_params; + + typedef typename property_value::type ew; + detail::graph::brandes_betweenness_centrality_dispatch1::run( + g, + choose_param(get_param(params, vertex_centrality), + dummy_property_map()), + choose_param(get_param(params, edge_centrality), + dummy_property_map()), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index), + get_param(params, edge_weight)); +} + +template +void +brandes_betweenness_centrality(const Graph& g, CentralityMap centrality) +{ + detail::graph::brandes_betweenness_centrality_dispatch2( + g, centrality, dummy_property_map(), get(vertex_index, g)); +} + +template +void +brandes_betweenness_centrality(const Graph& g, CentralityMap centrality, + EdgeCentralityMap edge_centrality_map) +{ + detail::graph::brandes_betweenness_centrality_dispatch2( + g, centrality, edge_centrality_map, get(vertex_index, g)); +} + +/** + * Converts "absolute" betweenness centrality (as computed by the + * brandes_betweenness_centrality algorithm) in the centrality map + * into "relative" centrality. The result is placed back into the + * given centrality map. + */ +template +void +relative_betweenness_centrality(const Graph& g, CentralityMap centrality) +{ + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename property_traits::value_type centrality_type; + + typename graph_traits::vertices_size_type n = num_vertices(g); + centrality_type factor = centrality_type(2)/centrality_type(n*n - 3*n + 2); + vertex_iterator v, v_end; + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + put(centrality, *v, factor * get(centrality, *v)); + } +} + +// Compute the central point dominance of a graph. +template +typename property_traits::value_type +central_point_dominance(const Graph& g, CentralityMap centrality) +{ + using std::max; + + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename property_traits::value_type centrality_type; + + typename graph_traits::vertices_size_type n = num_vertices(g); + + // Find max centrality + centrality_type max_centrality(0); + vertex_iterator v, v_end; + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + max_centrality = (max)(max_centrality, get(centrality, *v)); + } + + // Compute central point dominance + centrality_type sum(0); + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + sum += (max_centrality - get(centrality, *v)); + } + return sum/(n-1); +} + +} // end namespace boost + +#endif // BOOST_GRAPH_BRANDES_BETWEENNESS_CENTRALITY_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/biconnected_components.hpp b/deal.II/contrib/boost/include/boost/graph/biconnected_components.hpp new file mode 100644 index 0000000000..6baf586ce4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/biconnected_components.hpp @@ -0,0 +1,251 @@ +// Copyright (c) Jeremy Siek 2001 +// Copyright (c) Douglas Gregor 2004 +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// NOTE: this final is generated by libs/graph/doc/biconnected_components.w + +#ifndef BOOST_GRAPH_BICONNECTED_COMPONENTS_HPP +#define BOOST_GRAPH_BICONNECTED_COMPONENTS_HPP + +#include +#include +#include // for std::min and std::max +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + namespace detail + { + template + struct biconnected_components_visitor : public dfs_visitor<> + { + biconnected_components_visitor + (ComponentMap comp, std::size_t& c, DiscoverTimeMap dtm, + std::size_t& dfs_time, LowPointMap lowpt, PredecessorMap pred, + OutputIterator out, Stack& S) + : comp(comp), c(c), dtm(dtm), dfs_time(dfs_time), lowpt(lowpt), + pred(pred), out(out), S(S) { } + + template + void start_vertex(const Vertex& u, Graph&) + { + put(pred, u, u); + } + + template + void discover_vertex(const Vertex& u, Graph&) + { + put(dtm, u, ++dfs_time); + put(lowpt, u, get(dtm, u)); + } + + template + void tree_edge(const Edge& e, Graph& g) + { + S.push(e); + put(pred, target(e, g), source(e, g)); + } + + template + void back_edge(const Edge& e, Graph& g) + { + BOOST_USING_STD_MIN(); + + if ( target(e, g) != get(pred, source(e, g)) ) { + S.push(e); + put(lowpt, source(e, g), + min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, source(e, g)), + get(dtm, target(e, g)))); + } + } + + template + void finish_vertex(const Vertex& u, Graph& g) + { + BOOST_USING_STD_MIN(); + Vertex parent = get(pred, u); + bool is_art_point = false; + if ( get(dtm, parent) > get(dtm, u) ) { + parent = get(pred, parent); + is_art_point = true; + } + + if ( parent == u ) { // at top + if ( get(dtm, u) + 1 == get(dtm, get(pred, u)) ) + is_art_point = false; + } else { + put(lowpt, parent, + min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, parent), + get(lowpt, u))); + + if (get(lowpt, u) >= get(dtm, parent)) { + if ( get(dtm, parent) > get(dtm, get(pred, parent)) ) { + put(pred, u, get(pred, parent)); + put(pred, parent, u); + } + + while ( get(dtm, source(S.top(), g)) >= get(dtm, u) ) { + put(comp, S.top(), c); + S.pop(); + } + put(comp, S.top(), c); + S.pop(); + ++c; + if ( S.empty() ) { + put(pred, u, parent); + put(pred, parent, u); + } + } + } + if ( is_art_point ) + *out++ = u; + } + + ComponentMap comp; + std::size_t& c; + DiscoverTimeMap dtm; + std::size_t& dfs_time; + LowPointMap lowpt; + PredecessorMap pred; + OutputIterator out; + Stack& S; + }; + } // namespace detail + + template + std::pair + biconnected_components(const Graph & g, ComponentMap comp, + OutputIterator out, DiscoverTimeMap discover_time, + LowPointMap lowpt, PredecessorMap pred, + VertexIndexMap index_map) + { + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename graph_traits::edge_descriptor edge_t; + function_requires >(); + function_requires >(); + function_requires >(); + function_requires >(); + function_requires >(); + function_requires >(); + + std::size_t num_components = 0; + std::size_t dfs_time = 0; + std::stack < edge_t > S; + + detail::biconnected_components_visitor > + vis(comp, num_components, discover_time, dfs_time, lowpt, pred, out, S); + + depth_first_search(g, visitor(vis).vertex_index_map(index_map)); + + return std::pair(num_components, vis.out); + } + + template + std::pair + biconnected_components(const Graph & g, ComponentMap comp, + OutputIterator out, DiscoverTimeMap discover_time, + LowPointMap lowpt, VertexIndexMap index_map) + { + typedef typename graph_traits::vertex_descriptor vertex_t; + std::vector pred(num_vertices(g)); + vertex_t vert = graph_traits::null_vertex(); + return biconnected_components + (g, comp, out, discover_time, lowpt, + make_iterator_property_map(pred.begin(), index_map, vert), + index_map); + } + + template + std::pair + biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out, + VertexIndexMap index_map) + { + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename graph_traits::vertices_size_type + vertices_size_type; + + std::vector discover_time(num_vertices(g)); + std::vector lowpt(num_vertices(g)); + + vertices_size_type vst(0); + + return biconnected_components + (g, comp, out, + make_iterator_property_map(discover_time.begin(), index_map, vst), + make_iterator_property_map(lowpt.begin(), index_map, vst), + index_map); + } + + template < typename Graph, typename ComponentMap, typename OutputIterator> + std::pair + biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out) + { + return biconnected_components(g, comp, out, get(vertex_index, g)); + } + + namespace graph_detail { + struct dummy_output_iterator + { + typedef std::output_iterator_tag iterator_category; + typedef void value_type; + typedef void pointer; + typedef void difference_type; + + struct reference { + template + reference& operator=(const T&) { return *this; } + }; + + reference operator*() const { return reference(); } + dummy_output_iterator& operator++() { return *this; } + dummy_output_iterator operator++(int) { return *this; } + }; + } // end namespace graph_detail + + template + std::size_t + biconnected_components(const Graph& g, ComponentMap comp) + { + return biconnected_components(g, comp, + graph_detail::dummy_output_iterator()).first; + } + + template + OutputIterator + articulation_points(const Graph& g, OutputIterator out, + VertexIndexMap index_map) + { + return biconnected_components(g, dummy_property_map(), out, + index_map).second; + } + + template + OutputIterator + articulation_points(const Graph& g, OutputIterator out) + { + return biconnected_components(g, dummy_property_map(), out, + get(vertex_index, g)).second; + } + +} // namespace boost + +#endif /* BOOST_GRAPH_BICONNECTED_COMPONENTS_HPP */ diff --git a/deal.II/contrib/boost/include/boost/graph/breadth_first_search.hpp b/deal.II/contrib/boost/include/boost/graph/breadth_first_search.hpp new file mode 100644 index 0000000000..73416a485d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/breadth_first_search.hpp @@ -0,0 +1,293 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_BREADTH_FIRST_SEARCH_HPP +#define BOOST_GRAPH_BREADTH_FIRST_SEARCH_HPP + +/* + Breadth First Search Algorithm (Cormen, Leiserson, and Rivest p. 470) +*/ +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + struct BFSVisitorConcept { + void constraints() { + function_requires< CopyConstructibleConcept >(); + vis.initialize_vertex(u, g); + vis.discover_vertex(u, g); + vis.examine_vertex(u, g); + vis.examine_edge(e, g); + vis.tree_edge(e, g); + vis.non_tree_edge(e, g); + vis.gray_target(e, g); + vis.black_target(e, g); + vis.finish_vertex(u, g); + } + Visitor vis; + Graph g; + typename graph_traits::vertex_descriptor u; + typename graph_traits::edge_descriptor e; + }; + + + template + void breadth_first_visit + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor s, + Buffer& Q, BFSVisitor vis, ColorMap color) + { + function_requires< IncidenceGraphConcept >(); + typedef graph_traits GTraits; + typedef typename GTraits::vertex_descriptor Vertex; + typedef typename GTraits::edge_descriptor Edge; + function_requires< BFSVisitorConcept >(); + function_requires< ReadWritePropertyMapConcept >(); + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename GTraits::out_edge_iterator ei, ei_end; + + put(color, s, Color::gray()); vis.discover_vertex(s, g); + Q.push(s); + while (! Q.empty()) { + Vertex u = Q.top(); Q.pop(); vis.examine_vertex(u, g); + for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { + Vertex v = target(*ei, g); vis.examine_edge(*ei, g); + ColorValue v_color = get(color, v); + if (v_color == Color::white()) { vis.tree_edge(*ei, g); + put(color, v, Color::gray()); vis.discover_vertex(v, g); + Q.push(v); + } else { vis.non_tree_edge(*ei, g); + if (v_color == Color::gray()) vis.gray_target(*ei, g); + else vis.black_target(*ei, g); + } + } // end for + put(color, u, Color::black()); vis.finish_vertex(u, g); + } // end while + } // breadth_first_visit + + + template + void breadth_first_search + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + Buffer& Q, BFSVisitor vis, ColorMap color) + { + // Initialization + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename boost::graph_traits::vertex_iterator i, i_end; + for (tie(i, i_end) = vertices(g); i != i_end; ++i) { + put(color, *i, Color::white()); + vis.initialize_vertex(*i, g); + } + breadth_first_visit(g, s, Q, vis, color); + } + + + template + class bfs_visitor { + public: + bfs_visitor() { } + bfs_visitor(Visitors vis) : m_vis(vis) { } + + template + void initialize_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_initialize_vertex()); + } + template + void discover_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_discover_vertex()); + } + template + void examine_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_examine_vertex()); + } + template + void examine_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, ::boost::on_examine_edge()); + } + template + void tree_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, ::boost::on_tree_edge()); + } + template + void non_tree_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, ::boost::on_non_tree_edge()); + } + template + void gray_target(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, ::boost::on_gray_target()); + } + template + void black_target(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, ::boost::on_black_target()); + } + template + void finish_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_finish_vertex()); + } + + BOOST_GRAPH_EVENT_STUB(on_initialize_vertex,bfs) + BOOST_GRAPH_EVENT_STUB(on_discover_vertex,bfs) + BOOST_GRAPH_EVENT_STUB(on_examine_vertex,bfs) + BOOST_GRAPH_EVENT_STUB(on_examine_edge,bfs) + BOOST_GRAPH_EVENT_STUB(on_tree_edge,bfs) + BOOST_GRAPH_EVENT_STUB(on_non_tree_edge,bfs) + BOOST_GRAPH_EVENT_STUB(on_gray_target,bfs) + BOOST_GRAPH_EVENT_STUB(on_black_target,bfs) + BOOST_GRAPH_EVENT_STUB(on_finish_vertex,bfs) + + protected: + Visitors m_vis; + }; + template + bfs_visitor + make_bfs_visitor(Visitors vis) { + return bfs_visitor(vis); + } + typedef bfs_visitor<> default_bfs_visitor; + + + namespace detail { + + template + void bfs_helper + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + ColorMap color, + BFSVisitor vis, + const bgl_named_params& params) + { + typedef graph_traits Traits; + // Buffer default + typedef typename Traits::vertex_descriptor Vertex; + typedef boost::queue queue_t; + queue_t Q; + detail::wrap_ref Qref(Q); + breadth_first_search + (g, s, + choose_param(get_param(params, buffer_param_t()), Qref).ref, + vis, color); + } + + //------------------------------------------------------------------------- + // Choose between default color and color parameters. Using + // function dispatching so that we don't require vertex index if + // the color default is not being used. + + template + struct bfs_dispatch { + template + static void apply + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params, + ColorMap color) + { + bfs_helper + (g, s, color, + choose_param(get_param(params, graph_visitor), + make_bfs_visitor(null_visitor())), + params); + } + }; + + template <> + struct bfs_dispatch { + template + static void apply + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params, + detail::error_property_not_found) + { + std::vector color_vec(num_vertices(g)); + default_color_type c = white_color; + null_visitor null_vis; + + bfs_helper + (g, s, + make_iterator_property_map + (color_vec.begin(), + choose_const_pmap(get_param(params, vertex_index), + g, vertex_index), c), + choose_param(get_param(params, graph_visitor), + make_bfs_visitor(null_vis)), + params); + } + }; + + } // namespace detail + + + // Named Parameter Variant + template + void breadth_first_search + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params) + { + // The graph is passed by *const* reference so that graph adaptors + // (temporaries) can be passed into this function. However, the + // graph is not really const since we may write to property maps + // of the graph. + VertexListGraph& ng = const_cast(g); + typedef typename property_value< bgl_named_params, + vertex_color_t>::type C; + detail::bfs_dispatch::apply(ng, s, params, + get_param(params, vertex_color)); + } + + + // This version does not initialize colors, user has to. + + template + void breadth_first_visit + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params) + { + // The graph is passed by *const* reference so that graph adaptors + // (temporaries) can be passed into this function. However, the + // graph is not really const since we may write to property maps + // of the graph. + IncidenceGraph& ng = const_cast(g); + + typedef graph_traits Traits; + // Buffer default + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef boost::queue queue_t; + queue_t Q; + detail::wrap_ref Qref(Q); + + breadth_first_visit + (ng, s, + choose_param(get_param(params, buffer_param_t()), Qref).ref, + choose_param(get_param(params, graph_visitor), + make_bfs_visitor(null_visitor())), + choose_pmap(get_param(params, vertex_color), ng, vertex_color) + ); + } + +} // namespace boost + +#endif // BOOST_GRAPH_BREADTH_FIRST_SEARCH_HPP + diff --git a/deal.II/contrib/boost/include/boost/graph/circle_layout.hpp b/deal.II/contrib/boost/include/boost/graph/circle_layout.hpp new file mode 100644 index 0000000000..e601c5328c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/circle_layout.hpp @@ -0,0 +1,55 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_CIRCLE_LAYOUT_HPP +#define BOOST_GRAPH_CIRCLE_LAYOUT_HPP +#include +#include +#include + +namespace boost { + /** + * \brief Layout the graph with the vertices at the points of a regular + * n-polygon. + * + * The distance from the center of the polygon to each point is + * determined by the @p radius parameter. The @p position parameter + * must be an Lvalue Property Map whose value type is a class type + * containing @c x and @c y members that will be set to the @c x and + * @c y coordinates. + */ + template + void + circle_graph_layout(const VertexListGraph& g, PositionMap position, + Radius radius) + { + const double pi = 3.14159; + +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sin; + using std::cos; +#endif // BOOST_NO_STDC_NAMESPACE + + typedef typename graph_traits::vertices_size_type + vertices_size_type; + + vertices_size_type n = num_vertices(g); + + typedef typename graph_traits::vertex_iterator + vertex_iterator; + + vertices_size_type i = 0; + for(std::pair v = vertices(g); + v.first != v.second; ++v.first, ++i) { + position[*v.first].x = radius * cos(i * 2 * pi / n); + position[*v.first].y = radius * sin(i * 2 * pi / n); + } + } +} // end namespace boost + +#endif // BOOST_GRAPH_CIRCLE_LAYOUT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/connected_components.hpp b/deal.II/contrib/boost/include/boost/graph/connected_components.hpp new file mode 100644 index 0000000000..df9084ce36 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/connected_components.hpp @@ -0,0 +1,101 @@ +// +//======================================================================= +// Copyright 1997-2001 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_CONNECTED_COMPONENTS_HPP +#define BOOST_GRAPH_CONNECTED_COMPONENTS_HPP + +#include +#include +#include +#include + +#include + +namespace boost { + + namespace detail { + + // This visitor is used both in the connected_components algorithm + // and in the kosaraju strong components algorithm during the + // second DFS traversal. + template + class components_recorder : public dfs_visitor<> + { + typedef typename property_traits::value_type comp_type; + public: + components_recorder(ComponentsMap c, + comp_type& c_count) + : m_component(c), m_count(c_count) {} + + template + void start_vertex(Vertex, Graph&) { + if (m_count == (std::numeric_limits::max)()) + m_count = 0; // start counting components at zero + else + ++m_count; + } + template + void discover_vertex(Vertex u, Graph&) { + put(m_component, u, m_count); + } + protected: + ComponentsMap m_component; + comp_type& m_count; + }; + + } // namespace detail + + // This function computes the connected components of an undirected + // graph using a single application of depth first search. + + template + inline typename property_traits::value_type + connected_components(const Graph& g, ComponentMap c, + const bgl_named_params& params) + { + if (num_vertices(g) == 0) return 0; + + typedef typename graph_traits::vertex_descriptor Vertex; + function_requires< WritablePropertyMapConcept >(); + typedef typename boost::graph_traits::directed_category directed; + BOOST_STATIC_ASSERT((boost::is_same::value)); + + typedef typename property_traits::value_type comp_type; + // c_count initialized to "nil" (with nil represented by (max)()) + comp_type c_count((std::numeric_limits::max)()); + detail::components_recorder vis(c, c_count); + depth_first_search(g, params.visitor(vis)); + return c_count + 1; + } + + template + inline typename property_traits::value_type + connected_components(const Graph& g, ComponentMap c) + { + if (num_vertices(g) == 0) return 0; + + typedef typename graph_traits::vertex_descriptor Vertex; + function_requires< WritablePropertyMapConcept >(); + typedef typename boost::graph_traits::directed_category directed; + BOOST_STATIC_ASSERT((boost::is_same::value)); + + typedef typename property_traits::value_type comp_type; + // c_count initialized to "nil" (with nil represented by (max)()) + comp_type c_count((std::numeric_limits::max)()); + detail::components_recorder vis(c, c_count); + depth_first_search(g, visitor(vis)); + return c_count + 1; + } + + +} // namespace boost + + +#endif // BOOST_GRAPH_CONNECTED_COMPONENTS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/copy.hpp b/deal.II/contrib/boost/include/boost/graph/copy.hpp new file mode 100644 index 0000000000..fd98a426a4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/copy.hpp @@ -0,0 +1,450 @@ +// +//======================================================================= +// Copyright 1997-2001 University of Notre Dame. +// Authors: Jeremy G. Siek, Lie-Quan Lee, Andrew Lumsdaine +// +// 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) +//======================================================================= +// + +/* + This file implements the following functions: + + + template + void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out) + + template + void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out, + const bgl_named_params& params) + + + template + typename graph_traits::vertex_descriptor + copy_component(IncidenceGraph& g_in, + typename graph_traits::vertex_descriptor src, + MutableGraph& g_out) + + template + typename graph_traits::vertex_descriptor + copy_component(IncidenceGraph& g_in, + typename graph_traits::vertex_descriptor src, + MutableGraph& g_out, + const bgl_named_params& params) + */ + + +#ifndef BOOST_GRAPH_COPY_HPP +#define BOOST_GRAPH_COPY_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + namespace detail { + + // Default edge and vertex property copiers + + template + struct edge_copier { + edge_copier(const Graph1& g1, Graph2& g2) + : edge_all_map1(get(edge_all, g1)), + edge_all_map2(get(edge_all, g2)) { } + + template + void operator()(const Edge1& e1, Edge2& e2) const { + put(edge_all_map2, e2, get(edge_all_map1, e1)); + } + typename property_map::const_type edge_all_map1; + mutable typename property_map::type edge_all_map2; + }; + template + inline edge_copier + make_edge_copier(const Graph1& g1, Graph2& g2) + { + return edge_copier(g1, g2); + } + + template + struct vertex_copier { + vertex_copier(const Graph1& g1, Graph2& g2) + : vertex_all_map1(get(vertex_all, g1)), + vertex_all_map2(get(vertex_all, g2)) { } + + template + void operator()(const Vertex1& v1, Vertex2& v2) const { + put(vertex_all_map2, v2, get(vertex_all_map1, v1)); + } + typename property_map::const_type vertex_all_map1; + mutable typename property_map::type + vertex_all_map2; + }; + template + inline vertex_copier + make_vertex_copier(const Graph1& g1, Graph2& g2) + { + return vertex_copier(g1, g2); + } + + // Copy all the vertices and edges of graph g_in into graph g_out. + // The copy_vertex and copy_edge function objects control how vertex + // and edge properties are copied. + + template + struct copy_graph_impl { }; + + template <> struct copy_graph_impl<0> + { + template + static void apply(const Graph& g_in, MutableGraph& g_out, + CopyVertex copy_vertex, CopyEdge copy_edge, + Orig2CopyVertexIndexMap orig2copy, IndexMap) + { + typename graph_traits::vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) { + typename graph_traits::vertex_descriptor + new_v = add_vertex(g_out); + put(orig2copy, *vi, new_v); + copy_vertex(*vi, new_v); + } + typename graph_traits::edge_iterator ei, ei_end; + for (tie(ei, ei_end) = edges(g_in); ei != ei_end; ++ei) { + typename graph_traits::edge_descriptor new_e; + bool inserted; + tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)), + get(orig2copy, target(*ei, g_in)), + g_out); + copy_edge(*ei, new_e); + } + } + }; + + // for directed graphs + template <> struct copy_graph_impl<1> + { + template + static void apply(const Graph& g_in, MutableGraph& g_out, + CopyVertex copy_vertex, CopyEdge copy_edge, + Orig2CopyVertexIndexMap orig2copy, IndexMap) + { + typename graph_traits::vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) { + typename graph_traits::vertex_descriptor + new_v = add_vertex(g_out); + put(orig2copy, *vi, new_v); + copy_vertex(*vi, new_v); + } + for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) { + typename graph_traits::out_edge_iterator ei, ei_end; + for (tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) { + typename graph_traits::edge_descriptor new_e; + bool inserted; + tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)), + get(orig2copy, target(*ei, g_in)), + g_out); + copy_edge(*ei, new_e); + } + } + } + }; + + // for undirected graphs + template <> struct copy_graph_impl<2> + { + template + static void apply(const Graph& g_in, MutableGraph& g_out, + CopyVertex copy_vertex, CopyEdge copy_edge, + Orig2CopyVertexIndexMap orig2copy, + IndexMap index_map) + { + typedef color_traits Color; + std::vector + color(num_vertices(g_in), Color::white()); + typename graph_traits::vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) { + typename graph_traits::vertex_descriptor + new_v = add_vertex(g_out); + put(orig2copy, *vi, new_v); + copy_vertex(*vi, new_v); + } + for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) { + typename graph_traits::out_edge_iterator ei, ei_end; + for (tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) { + typename graph_traits::edge_descriptor new_e; + bool inserted; + if (color[get(index_map, target(*ei, g_in))] == Color::white()) { + tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei,g_in)), + get(orig2copy, target(*ei,g_in)), + g_out); + copy_edge(*ei, new_e); + } + } + color[get(index_map, *vi)] = Color::black(); + } + } + }; + + template + struct choose_graph_copy { + typedef typename Graph::traversal_category Trv; + typedef typename Graph::directed_category Dr; + enum { algo = + (is_convertible::value + && is_convertible::value) + ? 0 : is_convertible::value ? 1 : 2 }; + typedef copy_graph_impl type; + }; + + //------------------------------------------------------------------------- + struct choose_copier_parameter { + template + struct bind_ { + typedef const P& result_type; + static result_type apply(const P& p, const G1&, G2&) + { return p; } + }; + }; + struct choose_default_edge_copier { + template + struct bind_ { + typedef edge_copier result_type; + static result_type apply(const P&, const G1& g1, G2& g2) { + return result_type(g1, g2); + } + }; + }; + template + struct choose_edge_copy { + typedef choose_copier_parameter type; + }; + template <> + struct choose_edge_copy { + typedef choose_default_edge_copier type; + }; + template + struct choose_edge_copier_helper { + typedef typename choose_edge_copy::type Selector; + typedef typename Selector:: template bind_ Bind; + typedef Bind type; + typedef typename Bind::result_type result_type; + }; + template + typename detail::choose_edge_copier_helper::result_type + choose_edge_copier(const Param& params, const G1& g_in, G2& g_out) + { + typedef typename + detail::choose_edge_copier_helper::type Choice; + return Choice::apply(params, g_in, g_out); + } + + + struct choose_default_vertex_copier { + template + struct bind_ { + typedef vertex_copier result_type; + static result_type apply(const P&, const G1& g1, G2& g2) { + return result_type(g1, g2); + } + }; + }; + template + struct choose_vertex_copy { + typedef choose_copier_parameter type; + }; + template <> + struct choose_vertex_copy { + typedef choose_default_vertex_copier type; + }; + template + struct choose_vertex_copier_helper { + typedef typename choose_vertex_copy::type Selector; + typedef typename Selector:: template bind_ Bind; + typedef Bind type; + typedef typename Bind::result_type result_type; + }; + template + typename detail::choose_vertex_copier_helper::result_type + choose_vertex_copier(const Param& params, const G1& g_in, G2& g_out) + { + typedef typename + detail::choose_vertex_copier_helper::type Choice; + return Choice::apply(params, g_in, g_out); + } + + } // namespace detail + + + template + void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out) + { + if (num_vertices(g_in) == 0) + return; + typedef typename graph_traits::vertex_descriptor vertex_t; + std::vector orig2copy(num_vertices(g_in)); + typedef typename detail::choose_graph_copy::type + copy_impl; + copy_impl::apply + (g_in, g_out, + detail::make_vertex_copier(g_in, g_out), + detail::make_edge_copier(g_in, g_out), + make_iterator_property_map(orig2copy.begin(), + get(vertex_index, g_in), orig2copy[0]), + get(vertex_index, g_in) + ); + } + + template + void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out, + const bgl_named_params& params) + { + typename std::vector::size_type n; + n = is_default_param(get_param(params, orig_to_copy_t())) + ? num_vertices(g_in) : 1; + if (n == 0) + return; + std::vector::vertex_descriptor> + orig2copy(n); + + typedef typename detail::choose_graph_copy::type + copy_impl; + copy_impl::apply + (g_in, g_out, + detail::choose_vertex_copier(get_param(params, vertex_copy_t()), + g_in, g_out), + detail::choose_edge_copier(get_param(params, edge_copy_t()), + g_in, g_out), + choose_param(get_param(params, orig_to_copy_t()), + make_iterator_property_map + (orig2copy.begin(), + choose_const_pmap(get_param(params, vertex_index), + g_in, vertex_index), orig2copy[0])), + choose_const_pmap(get_param(params, vertex_index), g_in, vertex_index) + ); + } + + namespace detail { + + template + struct graph_copy_visitor : public bfs_visitor<> + { + graph_copy_visitor(NewGraph& graph, Copy2OrigIndexMap c, + CopyVertex cv, CopyEdge ce) + : g_out(graph), orig2copy(c), copy_vertex(cv), copy_edge(ce) { } + + template + void examine_vertex(Vertex u, const Graph& g_in) const { + typename graph_traits::vertex_descriptor + new_u = add_vertex(g_out); + put(orig2copy, u, new_u); + copy_vertex(u, new_u); + } + + template + void examine_edge(Edge e, const Graph& g_in) const { + typename graph_traits::edge_descriptor new_e; + bool inserted; + tie(new_e, inserted) = add_edge(get(orig2copy, source(e, g_in)), + get(orig2copy, target(e, g_in)), + g_out); + copy_edge(e, new_e); + } + private: + NewGraph& g_out; + Copy2OrigIndexMap orig2copy; + CopyVertex copy_vertex; + CopyEdge copy_edge; + }; + + template + typename graph_traits::vertex_descriptor + copy_component_impl + (const Graph& g_in, + typename graph_traits::vertex_descriptor src, + MutableGraph& g_out, + CopyVertex copy_vertex, CopyEdge copy_edge, + Orig2CopyVertexIndexMap orig2copy, + const Params& params) + { + graph_copy_visitor vis(g_out, orig2copy, copy_vertex, copy_edge); + breadth_first_search(g_in, src, params.visitor(vis)); + return get(orig2copy, src); + } + + } // namespace detail + + + // Copy all the vertices and edges of graph g_in that are reachable + // from the source vertex into graph g_out. Return the vertex + // in g_out that matches the source vertex of g_in. + template + typename graph_traits::vertex_descriptor + copy_component(IncidenceGraph& g_in, + typename graph_traits::vertex_descriptor src, + MutableGraph& g_out, + const bgl_named_params& params) + { + typename std::vector::size_type n; + n = is_default_param(get_param(params, orig_to_copy_t())) + ? num_vertices(g_in) : 1; + std::vector::vertex_descriptor> + orig2copy(n); + + return detail::copy_component_impl + (g_in, src, g_out, + detail::choose_vertex_copier(get_param(params, vertex_copy_t()), + g_in, g_out), + detail::choose_edge_copier(get_param(params, edge_copy_t()), + g_in, g_out), + choose_param(get_param(params, orig_to_copy_t()), + make_iterator_property_map + (orig2copy.begin(), + choose_pmap(get_param(params, vertex_index), + g_in, vertex_index), orig2copy[0])), + params + ); + } + + template + typename graph_traits::vertex_descriptor + copy_component(IncidenceGraph& g_in, + typename graph_traits::vertex_descriptor src, + MutableGraph& g_out) + { + std::vector::vertex_descriptor> + orig2copy(num_vertices(g_in)); + + return detail::copy_component_impl + (g_in, src, g_out, + make_vertex_copier(g_in, g_out), + make_edge_copier(g_in, g_out), + make_iterator_property_map(orig2copy.begin(), + get(vertex_index, g_in), orig2copy[0]), + bgl_named_params('x') // dummy param object + ); + } + +} // namespace boost + +#endif // BOOST_GRAPH_COPY_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/create_condensation_graph.hpp b/deal.II/contrib/boost/include/boost/graph/create_condensation_graph.hpp new file mode 100644 index 0000000000..f3d1113a3d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/create_condensation_graph.hpp @@ -0,0 +1,83 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_CREATE_CONDENSATION_GRAPH_HPP +#define BOOST_CREATE_CONDENSATION_GRAPH_HPP + +#include +#include + +namespace boost { + + template + void create_condensation_graph(const Graph& g, + const ComponentLists& components, + ComponentNumberMap component_number, + CondensationGraph& cg, + EdgeMultiplicityMap edge_mult_map) + { + typedef typename graph_traits::vertex_descriptor vertex; + typedef typename graph_traits::vertices_size_type size_type; + typedef typename graph_traits::vertex_descriptor + cg_vertex; + std::vector to_cg_vertex(components.size()); + for (size_type s = 0; s < components.size(); ++s) + to_cg_vertex[s] = add_vertex(cg); + + for (size_type si = 0; si < components.size(); ++si) { + cg_vertex s = to_cg_vertex[si]; + std::vector adj; + for (size_type i = 0; i < components[si].size(); ++i) { + vertex u = components[s][i]; + typename graph_traits::adjacency_iterator v, v_end; + for (tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) { + cg_vertex t = to_cg_vertex[component_number[*v]]; + if (s != t) // Avoid loops in the condensation graph + adj.push_back(t); + } + } + std::sort(adj.begin(), adj.end()); + if (! adj.empty()) { + size_type i = 0; + cg_vertex t = adj[i]; + typename graph_traits::edge_descriptor e; + bool inserted; + tie(e, inserted) = add_edge(s, t, cg); + put(edge_mult_map, e, 1); + ++i; + while (i < adj.size()) { + if (adj[i] == t) + put(edge_mult_map, e, get(edge_mult_map, e) + 1); + else { + t = adj[i]; + tie(e, inserted) = add_edge(s, t, cg); + put(edge_mult_map, e, 1); + } + ++i; + } + } + } + } + + template + void create_condensation_graph(const Graph& g, + const ComponentLists& components, + ComponentNumberMap component_number, + CondensationGraph& cg) + { + create_condensation_graph(g, components, component_number, cg, + dummy_property_map()); + } + +} // namespace boost + +#endif // BOOST_CREATE_CONDENSATION_GRAPH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/cuthill_mckee_ordering.hpp b/deal.II/contrib/boost/include/boost/graph/cuthill_mckee_ordering.hpp new file mode 100644 index 0000000000..5bfe9c12ab --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/cuthill_mckee_ordering.hpp @@ -0,0 +1,207 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek, +// Doug Gregor, D. Kevin McGrath +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// +#ifndef BOOST_GRAPH_CUTHILL_MCKEE_HPP +#define BOOST_GRAPH_CUTHILL_MCKEE_HPP + +#include +#include +#include + + +/* + (Reverse) Cuthill-McKee Algorithm for matrix reordering +*/ + +namespace boost { + + namespace detail { + + + + template < typename OutputIterator, typename Buffer, typename DegreeMap > + class bfs_rcm_visitor:public default_bfs_visitor + { + public: + bfs_rcm_visitor(OutputIterator *iter, Buffer *b, DegreeMap deg): + permutation(iter), Qptr(b), degree(deg) { } + template + void examine_vertex(Vertex u, Graph&) { + *(*permutation)++ = u; + index_begin = Qptr->size(); + } + template + void finish_vertex(Vertex, Graph&) { + using std::sort; + + typedef typename property_traits::value_type DS; + + typedef indirect_cmp > Compare; + Compare comp(degree); + + sort(Qptr->begin()+index_begin, Qptr->end(), comp); + } + protected: + OutputIterator *permutation; + int index_begin; + Buffer *Qptr; + DegreeMap degree; + }; + + } // namespace detail + + + // Reverse Cuthill-McKee algorithm with a given starting Vertex. + // + // If user provides a reverse iterator, this will be a reverse-cuthill-mckee + // algorithm, otherwise it will be a standard CM algorithm + + template + OutputIterator + cuthill_mckee_ordering(const Graph& g, + std::deque< typename + graph_traits::vertex_descriptor > vertex_queue, + OutputIterator permutation, + ColorMap color, DegreeMap degree) + { + + //create queue, visitor...don't forget namespaces! + typedef typename property_traits::value_type DS; + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename boost::sparse::sparse_ordering_queue queue; + typedef typename detail::bfs_rcm_visitor Visitor; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + + queue Q; + + //create a bfs_rcm_visitor as defined above + Visitor vis(&permutation, &Q, degree); + + typename graph_traits::vertex_iterator ui, ui_end; + + // Copy degree to pseudo_degree + // initialize the color map + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui){ + put(color, *ui, Color::white()); + } + + + while( !vertex_queue.empty() ) { + Vertex s = vertex_queue.front(); + vertex_queue.pop_front(); + + //call BFS with visitor + breadth_first_visit(g, s, Q, vis, color); + } + return permutation; + } + + + // This is the case where only a single starting vertex is supplied. + template + OutputIterator + cuthill_mckee_ordering(const Graph& g, + typename graph_traits::vertex_descriptor s, + OutputIterator permutation, + ColorMap color, DegreeMap degree) + { + + std::deque< typename graph_traits::vertex_descriptor > vertex_queue; + vertex_queue.push_front( s ); + + return cuthill_mckee_ordering(g, vertex_queue, permutation, color, degree); + + } + + + // This is the version of CM which selects its own starting vertex + template < class Graph, class OutputIterator, + class ColorMap, class DegreeMap> + OutputIterator + cuthill_mckee_ordering(const Graph& G, OutputIterator permutation, + ColorMap color, DegreeMap degree) + { + if (vertices(G).first == vertices(G).second) + return permutation; + + typedef typename boost::graph_traits::vertex_descriptor Vertex; + typedef typename boost::graph_traits::vertex_iterator VerIter; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + std::deque vertex_queue; + + // Mark everything white + BGL_FORALL_VERTICES_T(v, G, Graph) put(color, v, Color::white()); + + // Find one vertex from each connected component + BGL_FORALL_VERTICES_T(v, G, Graph) { + if (get(color, v) == Color::white()) { + depth_first_visit(G, v, dfs_visitor<>(), color); + vertex_queue.push_back(v); + } + } + + // Find starting nodes for all vertices + // TBD: How to do this with a directed graph? + for (typename std::deque::iterator i = vertex_queue.begin(); + i != vertex_queue.end(); ++i) + *i = find_starting_node(G, *i, color, degree); + + return cuthill_mckee_ordering(G, vertex_queue, permutation, + color, degree); + } + + template + OutputIterator + cuthill_mckee_ordering(const Graph& G, OutputIterator permutation, + VertexIndexMap index_map) + { + if (vertices(G).first == vertices(G).second) + return permutation; + + typedef out_degree_property_map DegreeMap; + std::vector colors(num_vertices(G)); + return cuthill_mckee_ordering(G, permutation, + make_iterator_property_map(&colors[0], + index_map, + colors[0]), + make_out_degree_map(G)); + } + + template + inline OutputIterator + cuthill_mckee_ordering(const Graph& G, OutputIterator permutation) + { return cuthill_mckee_ordering(G, permutation, get(vertex_index, G)); } +} // namespace boost + + +#endif // BOOST_GRAPH_CUTHILL_MCKEE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/dag_shortest_paths.hpp b/deal.II/contrib/boost/include/boost/graph/dag_shortest_paths.hpp new file mode 100644 index 0000000000..cc071de1f3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/dag_shortest_paths.hpp @@ -0,0 +1,157 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DAG_SHORTEST_PATHS_HPP +#define BOOST_GRAPH_DAG_SHORTEST_PATHS_HPP + +#include +#include + +// single-source shortest paths for a Directed Acyclic Graph (DAG) + +namespace boost { + + // Initalize distances and call depth first search + template + inline void + dag_shortest_paths + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + DistanceMap distance, WeightMap weight, ColorMap color, + PredecessorMap pred, + DijkstraVisitor vis, Compare compare, Combine combine, + DistInf inf, DistZero zero) + { + typedef typename graph_traits::vertex_descriptor Vertex; + std::vector rev_topo_order; + rev_topo_order.reserve(num_vertices(g)); + + // Call 'depth_first_visit', not 'topological_sort', because we don't + // want to traverse the entire graph, only vertices reachable from 's', + // and 'topological_sort' will traverse everything. The logic below + // is the same as for 'topological_sort', only we call 'depth_first_visit' + // and 'topological_sort' calls 'depth_first_search'. + topo_sort_visitor > > + topo_visitor(std::back_inserter(rev_topo_order)); + depth_first_visit(g, s, topo_visitor, color); + + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + put(distance, *ui, inf); + put(pred, *ui, *ui); + } + + put(distance, s, zero); + vis.discover_vertex(s, g); + typename std::vector::reverse_iterator i; + for (i = rev_topo_order.rbegin(); i != rev_topo_order.rend(); ++i) { + Vertex u = *i; + vis.examine_vertex(u, g); + typename graph_traits::out_edge_iterator e, e_end; + for (tie(e, e_end) = out_edges(u, g); e != e_end; ++e) { + vis.discover_vertex(target(*e, g), g); + bool decreased = relax(*e, g, weight, pred, distance, + combine, compare); + if (decreased) + vis.edge_relaxed(*e, g); + else + vis.edge_not_relaxed(*e, g); + } + vis.finish_vertex(u, g); + } + } + + namespace detail { + + // Defaults are the same as Dijkstra's algorithm + + // Handle Distance Compare, Combine, Inf and Zero defaults + template + inline void + dag_sp_dispatch2 + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + DistanceMap distance, WeightMap weight, ColorMap color, IndexMap id, + DijkstraVisitor vis, const Params& params) + { + typedef typename property_traits::value_type D; + dummy_property_map p_map; + dag_shortest_paths + (g, s, distance, weight, color, + choose_param(get_param(params, vertex_predecessor), p_map), + vis, + choose_param(get_param(params, distance_compare_t()), std::less()), + choose_param(get_param(params, distance_combine_t()), closed_plus()), + choose_param(get_param(params, distance_inf_t()), + (std::numeric_limits::max)()), + choose_param(get_param(params, distance_zero_t()), + D())); + } + + // Handle DistanceMap and ColorMap defaults + template + inline void + dag_sp_dispatch1 + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + DistanceMap distance, WeightMap weight, ColorMap color, IndexMap id, + DijkstraVisitor vis, const Params& params) + { + typedef typename property_traits::value_type T; + typename std::vector::size_type n; + n = is_default_param(distance) ? num_vertices(g) : 1; + std::vector distance_map(n); + n = is_default_param(color) ? num_vertices(g) : 1; + std::vector color_map(n); + + dag_sp_dispatch2 + (g, s, + choose_param(distance, + make_iterator_property_map(distance_map.begin(), id, + distance_map[0])), + weight, + choose_param(color, + make_iterator_property_map(color_map.begin(), id, + color_map[0])), + id, vis, params); + } + + } // namespace detail + + template + inline void + dag_shortest_paths + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params) + { + // assert that the graph is directed... + null_visitor null_vis; + detail::dag_sp_dispatch1 + (g, s, + get_param(params, vertex_distance), + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + get_param(params, vertex_color), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index), + choose_param(get_param(params, graph_visitor), + make_dijkstra_visitor(null_vis)), + params); + } + +} // namespace boost + +#endif // BOOST_GRAPH_DAG_SHORTEST_PATHS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/depth_first_search.hpp b/deal.II/contrib/boost/include/boost/graph/depth_first_search.hpp new file mode 100644 index 0000000000..588aa83fdd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/depth_first_search.hpp @@ -0,0 +1,360 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Copyright 2003 Bruce Barr +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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) +//======================================================================= + +// Nonrecursive implementation of depth_first_visit_impl submitted by +// Bruce Barr, schmoost yahoo.com, May/June 2003. +#ifndef BOOST_GRAPH_RECURSIVE_DFS_HPP +#define BOOST_GRAPH_RECURSIVE_DFS_HPP + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +namespace boost { + + template + class DFSVisitorConcept { + public: + void constraints() { + function_requires< CopyConstructibleConcept >(); + vis.initialize_vertex(u, g); + vis.start_vertex(u, g); + vis.discover_vertex(u, g); + vis.examine_edge(e, g); + vis.tree_edge(e, g); + vis.back_edge(e, g); + vis.forward_or_cross_edge(e, g); + vis.finish_vertex(u, g); + } + private: + Visitor vis; + Graph g; + typename graph_traits::vertex_descriptor u; + typename graph_traits::edge_descriptor e; + }; + + namespace detail { + + struct nontruth2 { + template + bool operator()(const T&, const T2&) const { return false; } + }; + + +// Define BOOST_RECURSIVE_DFS to use older, recursive version. +// It is retained for a while in order to perform performance +// comparison. +#ifndef BOOST_RECURSIVE_DFS + + // If the vertex u and the iterators ei and ei_end are thought of as the + // context of the algorithm, each push and pop from the stack could + // be thought of as a context shift. + // Each pass through "while (ei != ei_end)" may refer to the out-edges of + // an entirely different vertex, because the context of the algorithm + // shifts every time a white adjacent vertex is discovered. + // The corresponding context shift back from the adjacent vertex occurs + // after all of its out-edges have been examined. + // + // See http://lists.boost.org/MailArchives/boost/msg48752.php for FAQ. + + template + void depth_first_visit_impl + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor& vis, + ColorMap color, TerminatorFunc func = TerminatorFunc()) + { + function_requires >(); + function_requires >(); + typedef typename graph_traits::vertex_descriptor Vertex; + function_requires< ReadWritePropertyMapConcept >(); + typedef typename property_traits::value_type ColorValue; + function_requires< ColorValueConcept >(); + typedef color_traits Color; + typedef typename graph_traits::out_edge_iterator Iter; + typedef std::pair > VertexInfo; + + Iter ei, ei_end; + std::vector stack; + + // Possible optimization for vector + //stack.reserve(num_vertices(g)); + + typedef typename unwrap_reference::type TF; + + put(color, u, Color::gray()); + vis.discover_vertex(u, g); + tie(ei, ei_end) = out_edges(u, g); + // Variable is needed to workaround a borland bug. + TF& fn = static_cast(func); + if (fn(u, g)) { + // If this vertex terminates the search, we push empty range + stack.push_back(std::make_pair(u, std::make_pair(ei_end, ei_end))); + } else { + stack.push_back(std::make_pair(u, std::make_pair(ei, ei_end))); + } + while (!stack.empty()) { + VertexInfo& back = stack.back(); + u = back.first; + tie(ei, ei_end) = back.second; + stack.pop_back(); + while (ei != ei_end) { + Vertex v = target(*ei, g); + vis.examine_edge(*ei, g); + ColorValue v_color = get(color, v); + if (v_color == Color::white()) { + vis.tree_edge(*ei, g); + stack.push_back(std::make_pair(u, std::make_pair(++ei, ei_end))); + u = v; + put(color, u, Color::gray()); + vis.discover_vertex(u, g); + tie(ei, ei_end) = out_edges(u, g); + if (fn(u, g)) { + ei = ei_end; + } + } else if (v_color == Color::gray()) { + vis.back_edge(*ei, g); + ++ei; + } else { + vis.forward_or_cross_edge(*ei, g); + ++ei; + } + } + put(color, u, Color::black()); + vis.finish_vertex(u, g); + } + } + +#else // BOOST_RECURSIVE_DFS is defined + + template + void depth_first_visit_impl + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor& vis, // pass-by-reference here, important! + ColorMap color, TerminatorFunc func) + { + function_requires >(); + function_requires >(); + typedef typename graph_traits::vertex_descriptor Vertex; + function_requires< ReadWritePropertyMapConcept >(); + typedef typename property_traits::value_type ColorValue; + function_requires< ColorValueConcept >(); + typedef color_traits Color; + typename graph_traits::out_edge_iterator ei, ei_end; + + put(color, u, Color::gray()); vis.discover_vertex(u, g); + + typedef typename unwrap_reference::type TF; + // Variable is needed to workaround a borland bug. + TF& fn = static_cast(func); + if (!fn(u, g)) + for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { + Vertex v = target(*ei, g); vis.examine_edge(*ei, g); + ColorValue v_color = get(color, v); + if (v_color == Color::white()) { vis.tree_edge(*ei, g); + depth_first_visit_impl(g, v, vis, color, func); + } else if (v_color == Color::gray()) vis.back_edge(*ei, g); + else vis.forward_or_cross_edge(*ei, g); + } + put(color, u, Color::black()); vis.finish_vertex(u, g); + } + +#endif + + } // namespace detail + + template + void + depth_first_search(const VertexListGraph& g, DFSVisitor vis, ColorMap color, + typename graph_traits::vertex_descriptor start_vertex) + { + typedef typename graph_traits::vertex_descriptor Vertex; + function_requires >(); + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + put(color, *ui, Color::white()); vis.initialize_vertex(*ui, g); + } + + if (start_vertex != implicit_cast(*vertices(g).first)){ vis.start_vertex(start_vertex, g); + detail::depth_first_visit_impl(g, start_vertex, vis, color, + detail::nontruth2()); + } + + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + ColorValue u_color = get(color, *ui); + if (u_color == Color::white()) { vis.start_vertex(*ui, g); + detail::depth_first_visit_impl(g, *ui, vis, color, detail::nontruth2()); + } + } + } + + template + void + depth_first_search(const VertexListGraph& g, DFSVisitor vis, ColorMap color) + { + depth_first_search(g, vis, color, *vertices(g).first); + } + + namespace detail { + template + struct dfs_dispatch { + + template + static void + apply(const VertexListGraph& g, DFSVisitor vis, Vertex start_vertex, + const bgl_named_params&, + ColorMap color) + { + depth_first_search(g, vis, color, start_vertex); + } + }; + + template <> + struct dfs_dispatch { + template + static void + apply(const VertexListGraph& g, DFSVisitor vis, Vertex start_vertex, + const bgl_named_params& params, + detail::error_property_not_found) + { + std::vector color_vec(num_vertices(g)); + default_color_type c = white_color; // avoid warning about un-init + depth_first_search + (g, vis, make_iterator_property_map + (color_vec.begin(), + choose_const_pmap(get_param(params, vertex_index), + g, vertex_index), c), + start_vertex); + } + }; + } // namespace detail + + + template + class dfs_visitor { + public: + dfs_visitor() { } + dfs_visitor(Visitors vis) : m_vis(vis) { } + + template + void initialize_vertex(Vertex u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_initialize_vertex()); + } + template + void start_vertex(Vertex u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_start_vertex()); + } + template + void discover_vertex(Vertex u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_discover_vertex()); + } + template + void examine_edge(Edge u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_examine_edge()); + } + template + void tree_edge(Edge u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_tree_edge()); + } + template + void back_edge(Edge u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_back_edge()); + } + template + void forward_or_cross_edge(Edge u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_forward_or_cross_edge()); + } + template + void finish_vertex(Vertex u, const Graph& g) { + invoke_visitors(m_vis, u, g, ::boost::on_finish_vertex()); + } + + BOOST_GRAPH_EVENT_STUB(on_initialize_vertex,dfs) + BOOST_GRAPH_EVENT_STUB(on_start_vertex,dfs) + BOOST_GRAPH_EVENT_STUB(on_discover_vertex,dfs) + BOOST_GRAPH_EVENT_STUB(on_examine_edge,dfs) + BOOST_GRAPH_EVENT_STUB(on_tree_edge,dfs) + BOOST_GRAPH_EVENT_STUB(on_back_edge,dfs) + BOOST_GRAPH_EVENT_STUB(on_forward_or_cross_edge,dfs) + BOOST_GRAPH_EVENT_STUB(on_finish_vertex,dfs) + + protected: + Visitors m_vis; + }; + template + dfs_visitor + make_dfs_visitor(Visitors vis) { + return dfs_visitor(vis); + } + typedef dfs_visitor<> default_dfs_visitor; + + + // Named Parameter Variant + template + void + depth_first_search(const VertexListGraph& g, + const bgl_named_params& params) + { + typedef typename property_value< bgl_named_params, + vertex_color_t>::type C; + detail::dfs_dispatch::apply + (g, + choose_param(get_param(params, graph_visitor), + make_dfs_visitor(null_visitor())), + choose_param(get_param(params, root_vertex_t()), + *vertices(g).first), + params, + get_param(params, vertex_color) + ); + } + + template + void depth_first_visit + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor vis, ColorMap color) + { + vis.start_vertex(u, g); + detail::depth_first_visit_impl(g, u, vis, color, detail::nontruth2()); + } + + template + void depth_first_visit + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor vis, ColorMap color, TerminatorFunc func = TerminatorFunc()) + { + vis.start_vertex(u, g); + detail::depth_first_visit_impl(g, u, vis, color, func); + } + + +} // namespace boost + + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/detail/adj_list_edge_iterator.hpp b/deal.II/contrib/boost/include/boost/graph/detail/adj_list_edge_iterator.hpp new file mode 100644 index 0000000000..12cb6ee97a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/adj_list_edge_iterator.hpp @@ -0,0 +1,117 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_ADJ_LIST_EDGE_ITERATOR_HPP +#define BOOST_GRAPH_DETAIL_ADJ_LIST_EDGE_ITERATOR_HPP + +#include +#include +#include + +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) +# define BOOST_GRAPH_NO_OPTIONAL +#endif + +#ifdef BOOST_GRAPH_NO_OPTIONAL +# define BOOST_GRAPH_MEMBER . +#else +# define BOOST_GRAPH_MEMBER -> +# include +#endif // ndef BOOST_GRAPH_NO_OPTIONAL + +namespace boost { + + namespace detail { + + template + class adj_list_edge_iterator { + typedef adj_list_edge_iterator self; + public: + typedef std::forward_iterator_tag iterator_category; + typedef typename OutEdgeIterator::value_type value_type; + typedef typename OutEdgeIterator::reference reference; + typedef typename OutEdgeIterator::pointer pointer; + typedef typename OutEdgeIterator::difference_type difference_type; + typedef difference_type distance_type; + + inline adj_list_edge_iterator() {} + + inline adj_list_edge_iterator(const self& x) + : vBegin(x.vBegin), vCurr(x.vCurr), vEnd(x.vEnd), + edges(x.edges), m_g(x.m_g) { } + + template + inline adj_list_edge_iterator(VertexIterator b, + VertexIterator c, + VertexIterator e, + const G& g) + : vBegin(b), vCurr(c), vEnd(e), m_g(&g) { + if ( vCurr != vEnd ) { + while ( vCurr != vEnd && out_degree(*vCurr, *m_g) == 0 ) + ++vCurr; + if ( vCurr != vEnd ) + edges = out_edges(*vCurr, *m_g); + } + } + + /*Note: + In the directed graph cases, it is fine. + For undirected graphs, one edge go through twice. + */ + inline self& operator++() { + ++edges BOOST_GRAPH_MEMBER first; + if (edges BOOST_GRAPH_MEMBER first == edges BOOST_GRAPH_MEMBER second) + { + ++vCurr; + while ( vCurr != vEnd && out_degree(*vCurr, *m_g) == 0 ) + ++vCurr; + if ( vCurr != vEnd ) + edges = out_edges(*vCurr, *m_g); + } + return *this; + } + inline self operator++(int) { + self tmp = *this; + ++(*this); + return tmp; + } + inline value_type operator*() const + { return *edges BOOST_GRAPH_MEMBER first; } + inline bool operator==(const self& x) const { + return vCurr == x.vCurr + && (vCurr == vEnd + || edges BOOST_GRAPH_MEMBER first == x.edges BOOST_GRAPH_MEMBER first); + } + inline bool operator!=(const self& x) const { + return vCurr != x.vCurr + || (vCurr != vEnd + && edges BOOST_GRAPH_MEMBER first != x.edges BOOST_GRAPH_MEMBER first); + } + protected: + VertexIterator vBegin; + VertexIterator vCurr; + VertexIterator vEnd; + +#ifdef BOOST_GRAPH_NO_OPTIONAL + std::pair edges; +#else + boost::optional > + edges; +#endif // ndef BOOST_GRAPH_NO_OPTIONAL + const Graph* m_g; + }; + + } // namespace detail + +} + +#undef BOOST_GRAPH_MEMBER + +#endif // BOOST_GRAPH_DETAIL_ADJ_LIST_EDGE_ITERATOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/adjacency_list.hpp b/deal.II/contrib/boost/include/boost/graph/detail/adjacency_list.hpp new file mode 100644 index 0000000000..c27b0a6cbb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/adjacency_list.hpp @@ -0,0 +1,2744 @@ +// -*- c++ -*- +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_ADJACENCY_LIST_HPP +#define BOOST_GRAPH_DETAIL_ADJACENCY_LIST_HPP + +#include // for vertex_map in copy_impl +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +// Symbol truncation problems with MSVC, trying to shorten names. +#define stored_edge se_ +#define stored_edge_property sep_ +#define stored_edge_iter sei_ + +/* + Outline for this file: + + out_edge_iterator and in_edge_iterator implementation + edge_iterator for undirected graph + stored edge types (these object live in the out-edge/in-edge lists) + directed edges helper class + directed graph helper class + undirected graph helper class + bidirectional graph helper class + bidirectional graph helper class (without edge properties) + bidirectional graph helper class (with edge properties) + adjacency_list helper class + adj_list_impl class + vec_adj_list_impl class + adj_list_gen class + vertex property map + edge property map + + + Note: it would be nice to merge some of the undirected and + bidirectional code... it is aweful similar. + */ + + + +namespace boost { + + namespace detail { + + template + struct directed_category_traits { + typedef directed_tag directed_category; + }; + + template <> + struct directed_category_traits { + typedef directed_tag directed_category; + }; + template <> + struct directed_category_traits { + typedef undirected_tag directed_category; + }; + template <> + struct directed_category_traits { + typedef bidirectional_tag directed_category; + }; + + template + struct target_is { + target_is(const Vertex& v) : m_target(v) { } + template + bool operator()(const StoredEdge& e) const { + return e.get_target() == m_target; + } + Vertex m_target; + }; + + // O(E/V) + template + void erase_from_incidence_list(EdgeList& el, vertex_descriptor v, + allow_parallel_edge_tag) + { + boost::graph_detail::erase_if(el, detail::target_is(v)); + } + // O(log(E/V)) + template + void erase_from_incidence_list(EdgeList& el, vertex_descriptor v, + disallow_parallel_edge_tag) + { + typedef typename EdgeList::value_type StoredEdge; + el.erase(StoredEdge(v)); + } + + //========================================================================= + // Out-Edge and In-Edge Iterator Implementation + + template + struct out_edge_iter + : iterator_adaptor< + out_edge_iter + , BaseIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , Difference + > + { + typedef iterator_adaptor< + out_edge_iter + , BaseIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , Difference + > super_t; + + inline out_edge_iter() { } + inline out_edge_iter(const BaseIter& i, const VertexDescriptor& src) + : super_t(i), m_src(src) { } + + inline EdgeDescriptor + dereference() const + { + return EdgeDescriptor(m_src, (*this->base()).get_target(), + &(*this->base()).get_property()); + } + VertexDescriptor m_src; + }; + + template + struct in_edge_iter + : iterator_adaptor< + in_edge_iter + , BaseIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , Difference + > + { + typedef iterator_adaptor< + in_edge_iter + , BaseIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , Difference + > super_t; + + inline in_edge_iter() { } + inline in_edge_iter(const BaseIter& i, const VertexDescriptor& src) + : super_t(i), m_src(src) { } + + inline EdgeDescriptor + dereference() const + { + return EdgeDescriptor((*this->base()).get_target(), m_src, + &this->base()->get_property()); + } + VertexDescriptor m_src; + }; + + //========================================================================= + // Undirected Edge Iterator Implementation + + template + struct undirected_edge_iter + : iterator_adaptor< + undirected_edge_iter + , EdgeIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , Difference + > + { + typedef iterator_adaptor< + undirected_edge_iter + , EdgeIter + , EdgeDescriptor + , use_default + , EdgeDescriptor + , Difference + > super_t; + + undirected_edge_iter() {} + + explicit undirected_edge_iter(EdgeIter i) + : super_t(i) {} + + inline EdgeDescriptor + dereference() const { + return EdgeDescriptor( + (*this->base()).m_source + , (*this->base()).m_target + , &this->base()->get_property()); + } + }; + + //========================================================================= + // Edge Storage Types (stored in the out-edge/in-edge lists) + + template + class stored_edge + : public boost::equality_comparable1< stored_edge, + boost::less_than_comparable1< stored_edge > > + { + public: + typedef no_property property_type; + inline stored_edge() { } + inline stored_edge(Vertex target, const no_property& = no_property()) + : m_target(target) { } + // Need to write this explicitly so stored_edge_property can + // invoke Base::operator= (at least, for SGI MIPSPro compiler) + inline stored_edge& operator=(const stored_edge& x) { + m_target = x.m_target; + return *this; + } + inline Vertex& get_target() const { return m_target; } + inline const no_property& get_property() const { return s_prop; } + inline bool operator==(const stored_edge& x) const + { return m_target == x.get_target(); } + inline bool operator<(const stored_edge& x) const + { return m_target < x.get_target(); } + //protected: need to add hash<> as a friend + static no_property s_prop; + // Sometimes target not used as key in the set, and in that case + // it is ok to change the target. + mutable Vertex m_target; + }; + template + no_property stored_edge::s_prop; + + template + class stored_edge_property : public stored_edge { + typedef stored_edge_property self; + typedef stored_edge Base; + public: + typedef Property property_type; + inline stored_edge_property() { } + inline stored_edge_property(Vertex target, + const Property& p = Property()) + : stored_edge(target), m_property(new Property(p)) { } + stored_edge_property(const self& x) + : Base(x), m_property(const_cast(x).m_property) { } + self& operator=(const self& x) { + Base::operator=(x); + m_property = const_cast(x).m_property; + return *this; + } + inline Property& get_property() { return *m_property; } + inline const Property& get_property() const { return *m_property; } + protected: + // Holding the property by-value causes edge-descriptor + // invalidation for add_edge() with EdgeList=vecS. Instead we + // hold a pointer to the property. std::auto_ptr is not + // a perfect fit for the job, but it is darn close. + std::auto_ptr m_property; + }; + + + template + class stored_edge_iter + : public stored_edge + { + public: + typedef Property property_type; + inline stored_edge_iter() { } + inline stored_edge_iter(Vertex v) + : stored_edge(v) { } + inline stored_edge_iter(Vertex v, Iter i, void* = 0) + : stored_edge(v), m_iter(i) { } + inline Property& get_property() { return m_iter->get_property(); } + inline const Property& get_property() const { + return m_iter->get_property(); + } + inline Iter get_iter() const { return m_iter; } + protected: + Iter m_iter; + }; + + // For when the EdgeList is a std::vector. + // Want to make the iterator stable, so use an offset + // instead of an iterator into a std::vector + template + class stored_ra_edge_iter + : public stored_edge + { + typedef typename EdgeVec::iterator Iter; + public: + typedef Property property_type; + inline stored_ra_edge_iter() { } + inline stored_ra_edge_iter(Vertex v, Iter i = Iter(), + EdgeVec* edge_vec = 0) + : stored_edge(v), m_i(i - edge_vec->begin()), m_vec(edge_vec){ } + inline Property& get_property() { return (*m_vec)[m_i].get_property(); } + inline const Property& get_property() const { + return (*m_vec)[m_i].get_property(); + } + inline Iter get_iter() const { return m_vec->begin() + m_i; } + protected: + std::size_t m_i; + EdgeVec* m_vec; + }; + + } // namespace detail + + template + const typename property_value::type& + get(Tag property_tag, + const detail::stored_edge_property& e) + { + return get_property_value(e.get_property(), property_tag); + } + + template + const typename property_value::type& + get(Tag property_tag, + const detail::stored_edge_iter& e) + { + return get_property_value(e.get_property(), property_tag); + } + + template + const typename property_value::type& + get(Tag property_tag, + const detail::stored_ra_edge_iter& e) + { + return get_property_value(e.get_property(), property_tag); + } + + //========================================================================= + // Directed Edges Helper Class + + namespace detail { + + // O(E/V) + template + inline void + remove_directed_edge_dispatch(edge_descriptor, EdgeList& el, + StoredProperty& p) + { + for (typename EdgeList::iterator i = el.begin(); + i != el.end(); ++i) + if (&(*i).get_property() == &p) { + el.erase(i); + return; + } + } + + template + inline void + remove_directed_edge_if_dispatch(incidence_iterator first, + incidence_iterator last, + EdgeList& el, Predicate pred, + boost::allow_parallel_edge_tag) + { + // remove_if + while (first != last && !pred(*first)) + ++first; + incidence_iterator i = first; + if (first != last) + for (; i != last; ++i) + if (!pred(*i)) { + *first.base() = *i.base(); + ++first; + } + el.erase(first.base(), el.end()); + } + template + inline void + remove_directed_edge_if_dispatch(incidence_iterator first, + incidence_iterator last, + EdgeList& el, + Predicate pred, + boost::disallow_parallel_edge_tag) + { + for (incidence_iterator next = first; + first != last; first = next) { + ++next; + if (pred(*first)) + el.erase( first.base() ); + } + } + + template + inline void + undirected_remove_out_edge_if_dispatch(Graph& g, + incidence_iterator first, + incidence_iterator last, + EdgeList& el, Predicate pred, + boost::allow_parallel_edge_tag) + { + // remove_if + while (first != last && !pred(*first)) + ++first; + incidence_iterator i = first; + bool self_loop_removed = false; + if (first != last) + for (; i != last; ++i) { + if (self_loop_removed) { + /* With self loops, the descriptor will show up + * twice. The first time it will be removed, and now it + * will be skipped. + */ + self_loop_removed = false; + } + else if (!pred(*i)) { + *first.base() = *i.base(); + ++first; + } else { + if (source(*i, g) == target(*i, g)) self_loop_removed = true; + else { + // Remove the edge from the target + detail::remove_directed_edge_dispatch + (*i, + g.out_edge_list(target(*i, g)), + *(PropT*)(*i).get_property()); + } + + // Erase the edge property + g.m_edges.erase( (*i.base()).get_iter() ); + } + } + el.erase(first.base(), el.end()); + } + template + inline void + undirected_remove_out_edge_if_dispatch(Graph& g, + incidence_iterator first, + incidence_iterator last, + EdgeList& el, + Predicate pred, + boost::disallow_parallel_edge_tag) + { + for (incidence_iterator next = first; + first != last; first = next) { + ++next; + if (pred(*first)) { + if (source(*first, g) != target(*first, g)) { + // Remove the edge from the target + detail::remove_directed_edge_dispatch + (*first, + g.out_edge_list(target(*first, g)), + *(PropT*)(*first).get_property()); + } + + // Erase the edge property + g.m_edges.erase( (*first.base()).get_iter() ); + + // Erase the edge in the source + el.erase( first.base() ); + } + } + } + + // O(E/V) + template + inline void + remove_directed_edge_dispatch(edge_descriptor e, EdgeList& el, + no_property&) + { + for (typename EdgeList::iterator i = el.begin(); + i != el.end(); ++i) + if ((*i).get_target() == e.m_target) { + el.erase(i); + return; + } + } + + } // namespace detail + + template + struct directed_edges_helper { + + // Placement of these overloaded remove_edge() functions + // inside the class avoids a VC++ bug. + + // O(E/V) + inline void + remove_edge(typename Config::edge_descriptor e) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(*this); + typename Config::OutEdgeList& el = g.out_edge_list(source(e, g)); + typedef typename Config::OutEdgeList::value_type::property_type PType; + detail::remove_directed_edge_dispatch(e, el, + *(PType*)e.get_property()); + } + + // O(1) + inline void + remove_edge(typename Config::out_edge_iterator iter) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(*this); + typename Config::edge_descriptor e = *iter; + typename Config::OutEdgeList& el = g.out_edge_list(source(e, g)); + el.erase(iter.base()); + } + + }; + + // O(1) + template + inline std::pair + edges(const directed_edges_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_iterator edge_iterator; + const graph_type& cg = static_cast(g_); + graph_type& g = const_cast(cg); + return std::make_pair( edge_iterator(g.vertex_set().begin(), + g.vertex_set().begin(), + g.vertex_set().end(), g), + edge_iterator(g.vertex_set().begin(), + g.vertex_set().end(), + g.vertex_set().end(), g) ); + } + + //========================================================================= + // Directed Graph Helper Class + + struct adj_list_dir_traversal_tag : + public virtual vertex_list_graph_tag, + public virtual incidence_graph_tag, + public virtual adjacency_graph_tag, + public virtual edge_list_graph_tag { }; + + template + struct directed_graph_helper + : public directed_edges_helper { + typedef typename Config::edge_descriptor edge_descriptor; + typedef adj_list_dir_traversal_tag traversal_category; + }; + + // O(E/V) + template + inline void + remove_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + directed_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + detail::erase_from_incidence_list(g.out_edge_list(u), v, Cat()); + } + + template + inline void + remove_out_edge_if(typename Config::vertex_descriptor u, Predicate pred, + directed_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + typename Config::out_edge_iterator first, last; + tie(first, last) = out_edges(u, g); + typedef typename Config::edge_parallel_category edge_parallel_category; + detail::remove_directed_edge_if_dispatch + (first, last, g.out_edge_list(u), pred, edge_parallel_category()); + } + + template + inline void + remove_edge_if(Predicate pred, directed_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + + typename Config::vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + remove_out_edge_if(*vi, pred, g); + } + + template + inline void + remove_edge(EdgeOrIter e_or_iter, directed_graph_helper& g_) + { + g_.remove_edge(e_or_iter); + } + + // O(V + E) for allow_parallel_edges + // O(V * log(E/V)) for disallow_parallel_edges + template + inline void + clear_vertex(typename Config::vertex_descriptor u, + directed_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + typename Config::vertex_iterator vi, viend; + for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi) + detail::erase_from_incidence_list(g.out_edge_list(*vi), u, Cat()); + g.out_edge_list(u).clear(); + // clear() should be a req of Sequence and AssociativeContainer, + // or maybe just Container + } + + template + inline void + clear_out_edges(typename Config::vertex_descriptor u, + directed_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + g.out_edge_list(u).clear(); + // clear() should be a req of Sequence and AssociativeContainer, + // or maybe just Container + } + + // O(V), could do better... + template + inline typename Config::edges_size_type + num_edges(const directed_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + const graph_type& g = static_cast(g_); + typename Config::edges_size_type num_e = 0; + typename Config::vertex_iterator vi, vi_end; + for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + num_e += out_degree(*vi, g); + return num_e; + } + // O(1) for allow_parallel_edge_tag + // O(log(E/V)) for disallow_parallel_edge_tag + template + inline std::pair::edge_descriptor, bool> + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + const typename Config::edge_property_type& p, + directed_graph_helper& g_) + { + typedef typename Config::edge_descriptor edge_descriptor; + typedef typename Config::graph_type graph_type; + typedef typename Config::StoredEdge StoredEdge; + graph_type& g = static_cast(g_); + typename Config::OutEdgeList::iterator i; + bool inserted; + boost::tie(i, inserted) = boost::graph_detail::push(g.out_edge_list(u), + StoredEdge(v, p)); + return std::make_pair(edge_descriptor(u, v, &(*i).get_property()), + inserted); + } + // Did not use default argument here because that + // causes Visual C++ to get confused. + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + directed_graph_helper& g_) + { + typename Config::edge_property_type p; + return add_edge(u, v, p, g_); + } + //========================================================================= + // Undirected Graph Helper Class + + template + struct undirected_graph_helper; + + struct undir_adj_list_traversal_tag : + public virtual vertex_list_graph_tag, + public virtual incidence_graph_tag, + public virtual adjacency_graph_tag, + public virtual edge_list_graph_tag, + public virtual bidirectional_graph_tag { }; + + namespace detail { + + // using class with specialization for dispatch is a VC++ workaround. + template + struct remove_undirected_edge_dispatch { + + // O(E/V) + template + static void + apply(edge_descriptor e, + undirected_graph_helper& g_, + StoredProperty& p) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + + typename Config::OutEdgeList& out_el = g.out_edge_list(source(e, g)); + typename Config::OutEdgeList::iterator out_i = out_el.begin(); + for (; out_i != out_el.end(); ++out_i) + if (&(*out_i).get_property() == &p) { + out_el.erase(out_i); + break; + } + typename Config::OutEdgeList& in_el = g.out_edge_list(target(e, g)); + typename Config::OutEdgeList::iterator in_i = in_el.begin(); + for (; in_i != in_el.end(); ++in_i) + if (&(*in_i).get_property() == &p) { + g.m_edges.erase((*in_i).get_iter()); + in_el.erase(in_i); + return; + } + } + }; + + template <> + struct remove_undirected_edge_dispatch { + // O(E/V) + template + static void + apply(edge_descriptor e, + undirected_graph_helper& g_, + no_property&) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + no_property* p = (no_property*)e.get_property(); + typename Config::OutEdgeList& out_el = g.out_edge_list(source(e, g)); + typename Config::OutEdgeList::iterator out_i = out_el.begin(); + for (; out_i != out_el.end(); ++out_i) + if (&(*out_i).get_property() == p) { + out_el.erase(out_i); + break; + } + typename Config::OutEdgeList& in_el = g.out_edge_list(target(e, g)); + typename Config::OutEdgeList::iterator in_i = in_el.begin(); + for (; in_i != in_el.end(); ++in_i) + if (&(*in_i).get_property() == p) { + g.m_edges.erase((*in_i).get_iter()); + in_el.erase(in_i); + return; + } + } + }; + + // O(E/V) + template + inline void + remove_edge_and_property(Graph& g, EdgeList& el, Vertex v, + boost::allow_parallel_edge_tag cat) + { + typedef typename EdgeList::value_type StoredEdge; + typename EdgeList::iterator i = el.begin(), end = el.end(); + for (; i != end; ++i) + if ((*i).get_target() == v) + g.m_edges.erase((*i).get_iter()); + detail::erase_from_incidence_list(el, v, cat); + } + // O(log(E/V)) + template + inline void + remove_edge_and_property(Graph& g, EdgeList& el, Vertex v, + boost::disallow_parallel_edge_tag) + { + typedef typename EdgeList::value_type StoredEdge; + typename EdgeList::iterator i = el.find(StoredEdge(v)), end = el.end(); + if (i != end) { + g.m_edges.erase((*i).get_iter()); + el.erase(i); + } + } + + } // namespace detail + + template + struct list_edge // short name due to VC++ truncation and linker problems + : public boost::detail::edge_base + { + typedef EdgeProperty property_type; + typedef boost::detail::edge_base Base; + list_edge(Vertex u, Vertex v, const EdgeProperty& p = EdgeProperty()) + : Base(u, v), m_property(p) { } + EdgeProperty& get_property() { return m_property; } + const EdgeProperty& get_property() const { return m_property; } + // the following methods should never be used, but are needed + // to make SGI MIPSpro C++ happy + list_edge() { } + bool operator==(const list_edge&) const { return false; } + bool operator<(const list_edge&) const { return false; } + EdgeProperty m_property; + }; + + template + struct undirected_graph_helper { + + typedef undir_adj_list_traversal_tag traversal_category; + + // Placement of these overloaded remove_edge() functions + // inside the class avoids a VC++ bug. + + // O(E/V) + inline void + remove_edge(typename Config::edge_descriptor e) + { + typedef typename Config::OutEdgeList::value_type::property_type PType; + detail::remove_undirected_edge_dispatch::apply + (e, *this, *(PType*)e.get_property()); + } + // O(E/V) + inline void + remove_edge(typename Config::out_edge_iterator iter) + { + this->remove_edge(*iter); + } + }; + + // Had to make these non-members to avoid accidental instantiation + // on SGI MIPSpro C++ + template + inline typename C::InEdgeList& + in_edge_list(undirected_graph_helper&, + typename C::vertex_descriptor v) + { + typename C::stored_vertex* sv = (typename C::stored_vertex*)v; + return sv->m_out_edges; + } + template + inline const typename C::InEdgeList& + in_edge_list(const undirected_graph_helper&, + typename C::vertex_descriptor v) { + typename C::stored_vertex* sv = (typename C::stored_vertex*)v; + return sv->m_out_edges; + } + + // O(E/V) + template + inline void + remove_edge(EdgeOrIter e, undirected_graph_helper& g_) + { + g_.remove_edge(e); + } + + // O(E/V) or O(log(E/V)) + template + void + remove_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + undirected_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + typedef typename Config::edge_parallel_category Cat; + detail::remove_edge_and_property(g, g.out_edge_list(u), v, Cat()); + detail::erase_from_incidence_list(g.out_edge_list(v), u, Cat()); + } + + template + void + remove_out_edge_if(typename Config::vertex_descriptor u, Predicate pred, + undirected_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::OutEdgeList::value_type::property_type PropT; + graph_type& g = static_cast(g_); + typename Config::out_edge_iterator first, last; + tie(first, last) = out_edges(u, g); + typedef typename Config::edge_parallel_category Cat; + detail::undirected_remove_out_edge_if_dispatch + (g, first, last, g.out_edge_list(u), pred, Cat()); + } + template + void + remove_in_edge_if(typename Config::vertex_descriptor u, Predicate pred, + undirected_graph_helper& g_) + { + remove_out_edge_if(u, pred, g_); + } + + // O(E/V * E) or O(log(E/V) * E) + template + void + remove_edge_if(Predicate pred, undirected_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + typename Config::edge_iterator ei, ei_end, next; + tie(ei, ei_end) = edges(g); + for (next = ei; ei != ei_end; ei = next) { + ++next; + if (pred(*ei)) + remove_edge(*ei, g); + } + } + + // O(1) + template + inline std::pair + edges(const undirected_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_iterator edge_iterator; + const graph_type& cg = static_cast(g_); + graph_type& g = const_cast(cg); + return std::make_pair( edge_iterator(g.m_edges.begin()), + edge_iterator(g.m_edges.end()) ); + } + // O(1) + template + inline typename Config::edges_size_type + num_edges(const undirected_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + const graph_type& g = static_cast(g_); + return g.m_edges.size(); + } + // O(E/V * E/V) + template + inline void + clear_vertex(typename Config::vertex_descriptor u, + undirected_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + typename Config::OutEdgeList& el = g.out_edge_list(u); + typename Config::OutEdgeList::iterator + ei = el.begin(), ei_end = el.end(); + for (; ei != ei_end; ++ei) { + detail::erase_from_incidence_list + (g.out_edge_list((*ei).get_target()), u, Cat()); + g.m_edges.erase((*ei).get_iter()); + } + g.out_edge_list(u).clear(); + } + // O(1) for allow_parallel_edge_tag + // O(log(E/V)) for disallow_parallel_edge_tag + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + const typename Config::edge_property_type& p, + undirected_graph_helper& g_) + { + typedef typename Config::StoredEdge StoredEdge; + typedef typename Config::edge_descriptor edge_descriptor; + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + + bool inserted; + typename Config::EdgeContainer::value_type e(u, v, p); + g.m_edges.push_back(e); + typename Config::EdgeContainer::iterator p_iter + = boost::prior(g.m_edges.end()); + typename Config::OutEdgeList::iterator i; + boost::tie(i, inserted) = boost::graph_detail::push(g.out_edge_list(u), + StoredEdge(v, p_iter, &g.m_edges)); + if (inserted) { + boost::graph_detail::push(g.out_edge_list(v), StoredEdge(u, p_iter, &g.m_edges)); + return std::make_pair(edge_descriptor(u, v, &p_iter->get_property()), + true); + } else { + g.m_edges.erase(p_iter); + return std::make_pair + (edge_descriptor(u, v, &i->get_iter()->get_property()), false); + } + } + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + undirected_graph_helper& g_) + { + typename Config::edge_property_type p; + return add_edge(u, v, p, g_); + } + + // O(1) + template + inline typename Config::degree_size_type + degree(typename Config::vertex_descriptor u, + const undirected_graph_helper& g_) + { + typedef typename Config::graph_type Graph; + const Graph& g = static_cast(g_); + return out_degree(u, g); + } + + template + inline std::pair + in_edges(typename Config::vertex_descriptor u, + const undirected_graph_helper& g_) + { + typedef typename Config::graph_type Graph; + const Graph& cg = static_cast(g_); + Graph& g = const_cast(cg); + typedef typename Config::in_edge_iterator in_edge_iterator; + return + std::make_pair(in_edge_iterator(g.out_edge_list(u).begin(), u), + in_edge_iterator(g.out_edge_list(u).end(), u)); + } + + template + inline typename Config::degree_size_type + in_degree(typename Config::vertex_descriptor u, + const undirected_graph_helper& g_) + { return degree(u, g_); } + + //========================================================================= + // Bidirectional Graph Helper Class + + struct bidir_adj_list_traversal_tag : + public virtual vertex_list_graph_tag, + public virtual incidence_graph_tag, + public virtual adjacency_graph_tag, + public virtual edge_list_graph_tag, + public virtual bidirectional_graph_tag { }; + + template + struct bidirectional_graph_helper + : public directed_edges_helper { + typedef bidir_adj_list_traversal_tag traversal_category; + }; + + // Had to make these non-members to avoid accidental instantiation + // on SGI MIPSpro C++ + template + inline typename C::InEdgeList& + in_edge_list(bidirectional_graph_helper&, + typename C::vertex_descriptor v) + { + typename C::stored_vertex* sv = (typename C::stored_vertex*)v; + return sv->m_in_edges; + } + template + inline const typename C::InEdgeList& + in_edge_list(const bidirectional_graph_helper&, + typename C::vertex_descriptor v) { + typename C::stored_vertex* sv = (typename C::stored_vertex*)v; + return sv->m_in_edges; + } + + template + inline void + remove_edge_if(Predicate pred, bidirectional_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + typename Config::edge_iterator ei, ei_end, next; + tie(ei, ei_end) = edges(g); + for (next = ei; ei != ei_end; ei = next) { + ++next; + if (pred(*ei)) + remove_edge(*ei, g); + } + } + + template + inline std::pair + in_edges(typename Config::vertex_descriptor u, + const bidirectional_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + const graph_type& cg = static_cast(g_); + graph_type& g = const_cast(cg); + typedef typename Config::in_edge_iterator in_edge_iterator; + return + std::make_pair(in_edge_iterator(in_edge_list(g, u).begin(), u), + in_edge_iterator(in_edge_list(g, u).end(), u)); + } + + // O(1) + template + inline std::pair + edges(const bidirectional_graph_helper& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_iterator edge_iterator; + const graph_type& cg = static_cast(g_); + graph_type& g = const_cast(cg); + return std::make_pair( edge_iterator(g.m_edges.begin()), + edge_iterator(g.m_edges.end()) ); + } + + //========================================================================= + // Bidirectional Graph Helper Class (with edge properties) + + + template + struct bidirectional_graph_helper_with_property + : public bidirectional_graph_helper + { + typedef typename Config::graph_type graph_type; + typedef typename Config::out_edge_iterator out_edge_iterator; + + std::pair + get_parallel_edge_sublist(typename Config::edge_descriptor e, + const graph_type& g, + void*) + { return out_edges(source(e, g), g); } + + std::pair + get_parallel_edge_sublist(typename Config::edge_descriptor e, + const graph_type& g, + setS*) + { return edge_range(source(e, g), target(e, g), g); } + + std::pair + get_parallel_edge_sublist(typename Config::edge_descriptor e, + const graph_type& g, + multisetS*) + { return edge_range(source(e, g), target(e, g), g); } + +#if !defined BOOST_NO_HASH + std::pair + get_parallel_edge_sublist(typename Config::edge_descriptor e, + const graph_type& g, + hash_setS*) + { return edge_range(source(e, g), target(e, g), g); } +#endif + + // Placement of these overloaded remove_edge() functions + // inside the class avoids a VC++ bug. + + // O(E/V) or O(log(E/V)) + void + remove_edge(typename Config::edge_descriptor e) + { + graph_type& g = static_cast(*this); + + typedef typename Config::edgelist_selector OutEdgeListS; + + std::pair rng = + get_parallel_edge_sublist(e, g, (OutEdgeListS*)(0)); + rng.first = std::find(rng.first, rng.second, e); + assert(rng.first != rng.second); + remove_edge(rng.first); + } + + inline void + remove_edge(typename Config::out_edge_iterator iter) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(*this); + typename Config::edge_descriptor e = *iter; + typename Config::OutEdgeList& oel = g.out_edge_list(source(e, g)); + typename Config::InEdgeList& iel = in_edge_list(g, target(e, g)); + typedef typename Config::OutEdgeList::value_type::property_type PType; + PType& p = *(PType*)e.get_property(); + detail::remove_directed_edge_dispatch(*iter, iel, p); + g.m_edges.erase(iter.base()->get_iter()); + oel.erase(iter.base()); + } + }; + + // O(E/V) for allow_parallel_edge_tag + // O(log(E/V)) for disallow_parallel_edge_tag + template + inline void + remove_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + typedef typename Config::edge_parallel_category Cat; + detail::remove_edge_and_property(g, g.out_edge_list(u), v, Cat()); + detail::erase_from_incidence_list(in_edge_list(g, v), u, Cat()); + } + + // O(E/V) or O(log(E/V)) + template + inline void + remove_edge(EdgeOrIter e, + bidirectional_graph_helper_with_property& g_) + { + g_.remove_edge(e); + } + + template + inline void + remove_out_edge_if(typename Config::vertex_descriptor u, Predicate pred, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::OutEdgeList::value_type::property_type PropT; + graph_type& g = static_cast(g_); + + typedef typename Config::EdgeIter EdgeIter; + typedef std::vector Garbage; + Garbage garbage; + + // First remove the edges from the targets' in-edge lists and + // from the graph's edge set list. + typename Config::out_edge_iterator out_i, out_end; + for (tie(out_i, out_end) = out_edges(u, g); out_i != out_end; ++out_i) + if (pred(*out_i)) { + detail::remove_directed_edge_dispatch + (*out_i, in_edge_list(g, target(*out_i, g)), + *(PropT*)(*out_i).get_property()); + // Put in garbage to delete later. Will need the properties + // for the remove_if of the out-edges. + garbage.push_back((*out_i.base()).get_iter()); + } + + // Now remove the edges from this out-edge list. + typename Config::out_edge_iterator first, last; + tie(first, last) = out_edges(u, g); + typedef typename Config::edge_parallel_category Cat; + detail::remove_directed_edge_if_dispatch + (first, last, g.out_edge_list(u), pred, Cat()); + + // Now delete the edge properties from the g.m_edges list + for (typename Garbage::iterator i = garbage.begin(); + i != garbage.end(); ++i) + g.m_edges.erase(*i); + } + template + inline void + remove_in_edge_if(typename Config::vertex_descriptor v, Predicate pred, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::OutEdgeList::value_type::property_type PropT; + graph_type& g = static_cast(g_); + + typedef typename Config::EdgeIter EdgeIter; + typedef std::vector Garbage; + Garbage garbage; + + // First remove the edges from the sources' out-edge lists and + // from the graph's edge set list. + typename Config::in_edge_iterator in_i, in_end; + for (tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i) + if (pred(*in_i)) { + typename Config::vertex_descriptor u = source(*in_i, g); + detail::remove_directed_edge_dispatch + (*in_i, g.out_edge_list(u), *(PropT*)(*in_i).get_property()); + // Put in garbage to delete later. Will need the properties + // for the remove_if of the out-edges. + garbage.push_back((*in_i.base()).get_iter()); + } + // Now remove the edges from this in-edge list. + typename Config::in_edge_iterator first, last; + tie(first, last) = in_edges(v, g); + typedef typename Config::edge_parallel_category Cat; + detail::remove_directed_edge_if_dispatch + (first, last, in_edge_list(g, v), pred, Cat()); + + // Now delete the edge properties from the g.m_edges list + for (typename Garbage::iterator i = garbage.begin(); + i != garbage.end(); ++i) + g.m_edges.erase(*i); + } + + // O(1) + template + inline typename Config::edges_size_type + num_edges(const bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + const graph_type& g = static_cast(g_); + return g.m_edges.size(); + } + // O(E/V * E/V) for allow_parallel_edge_tag + // O(E/V * log(E/V)) for disallow_parallel_edge_tag + template + inline void + clear_vertex(typename Config::vertex_descriptor u, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + typename Config::OutEdgeList& el = g.out_edge_list(u); + typename Config::OutEdgeList::iterator + ei = el.begin(), ei_end = el.end(); + for (; ei != ei_end; ++ei) { + detail::erase_from_incidence_list + (in_edge_list(g, (*ei).get_target()), u, Cat()); + g.m_edges.erase((*ei).get_iter()); + } + typename Config::InEdgeList& in_el = in_edge_list(g, u); + typename Config::InEdgeList::iterator + in_ei = in_el.begin(), in_ei_end = in_el.end(); + for (; in_ei != in_ei_end; ++in_ei) { + detail::erase_from_incidence_list + (g.out_edge_list((*in_ei).get_target()), u, Cat()); + g.m_edges.erase((*in_ei).get_iter()); + } + g.out_edge_list(u).clear(); + in_edge_list(g, u).clear(); + } + + template + inline void + clear_out_edges(typename Config::vertex_descriptor u, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + typename Config::OutEdgeList& el = g.out_edge_list(u); + typename Config::OutEdgeList::iterator + ei = el.begin(), ei_end = el.end(); + for (; ei != ei_end; ++ei) { + detail::erase_from_incidence_list + (in_edge_list(g, (*ei).get_target()), u, Cat()); + g.m_edges.erase((*ei).get_iter()); + } + g.out_edge_list(u).clear(); + } + + template + inline void + clear_in_edges(typename Config::vertex_descriptor u, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + typedef typename Config::edge_parallel_category Cat; + graph_type& g = static_cast(g_); + typename Config::InEdgeList& in_el = in_edge_list(g, u); + typename Config::InEdgeList::iterator + in_ei = in_el.begin(), in_ei_end = in_el.end(); + for (; in_ei != in_ei_end; ++in_ei) { + detail::erase_from_incidence_list + (g.out_edge_list((*in_ei).get_target()), u, Cat()); + g.m_edges.erase((*in_ei).get_iter()); + } + in_edge_list(g, u).clear(); + } + + // O(1) for allow_parallel_edge_tag + // O(log(E/V)) for disallow_parallel_edge_tag + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + const typename Config::edge_property_type& p, + bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + graph_type& g = static_cast(g_); + typedef typename Config::edge_descriptor edge_descriptor; + typedef typename Config::StoredEdge StoredEdge; + bool inserted; + typename Config::EdgeContainer::value_type e(u, v, p); + g.m_edges.push_back(e); + typename Config::EdgeContainer::iterator p_iter + = boost::prior(g.m_edges.end()); + typename Config::OutEdgeList::iterator i; + boost::tie(i, inserted) = boost::graph_detail::push(g.out_edge_list(u), + StoredEdge(v, p_iter, &g.m_edges)); + if (inserted) { + boost::graph_detail::push(in_edge_list(g, v), StoredEdge(u, p_iter, &g.m_edges)); + return std::make_pair(edge_descriptor(u, v, &p_iter->m_property), + true); + } else { + g.m_edges.erase(p_iter); + return std::make_pair(edge_descriptor(u, v, + &i->get_iter()->get_property()), + false); + } + } + + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + bidirectional_graph_helper_with_property& g_) + { + typename Config::edge_property_type p; + return add_edge(u, v, p, g_); + } + // O(1) + template + inline typename Config::degree_size_type + degree(typename Config::vertex_descriptor u, + const bidirectional_graph_helper_with_property& g_) + { + typedef typename Config::graph_type graph_type; + const graph_type& g = static_cast(g_); + return in_degree(u, g) + out_degree(u, g); + } + + //========================================================================= + // Adjacency List Helper Class + + template + struct adj_list_helper : public Base + { + typedef typename Config::graph_type AdjList; + typedef typename Config::vertex_descriptor vertex_descriptor; + typedef typename Config::edge_descriptor edge_descriptor; + typedef typename Config::out_edge_iterator out_edge_iterator; + typedef typename Config::in_edge_iterator in_edge_iterator; + typedef typename Config::adjacency_iterator adjacency_iterator; + typedef typename Config::inv_adjacency_iterator inv_adjacency_iterator; + typedef typename Config::vertex_iterator vertex_iterator; + typedef typename Config::edge_iterator edge_iterator; + typedef typename Config::directed_category directed_category; + typedef typename Config::edge_parallel_category edge_parallel_category; + typedef typename Config::vertices_size_type vertices_size_type; + typedef typename Config::edges_size_type edges_size_type; + typedef typename Config::degree_size_type degree_size_type; + typedef typename Config::StoredEdge StoredEdge; + typedef typename Config::edge_property_type edge_property_type; + + // protected: + + // The edge_dispatch() functions should be static, but + // Borland gets confused about constness. + + // O(E/V) + inline std::pair + edge_dispatch(const AdjList& g, + vertex_descriptor u, vertex_descriptor v, + boost::allow_parallel_edge_tag) const + { + bool found; + const typename Config::OutEdgeList& el = g.out_edge_list(u); + typename Config::OutEdgeList::const_iterator + i = std::find_if(el.begin(), el.end(), + detail::target_is(v)); + found = (i != g.out_edge_list(u).end()); + if (found) + return std::make_pair(edge_descriptor(u, v, &(*i).get_property()), + true); + else + return std::make_pair(edge_descriptor(u, v, 0), false); + } + // O(log(E/V)) + inline std::pair + edge_dispatch(const AdjList& g, + vertex_descriptor u, vertex_descriptor v, + boost::disallow_parallel_edge_tag) const + { + bool found; + /* According to the standard, this should be iterator, not const_iterator, + but the VC++ std::set::find() const returns const_iterator. + And since iterator should be convertible to const_iterator, the + following should work everywhere. -Jeremy */ + typename Config::OutEdgeList::const_iterator + i = g.out_edge_list(u).find(StoredEdge(v)), + end = g.out_edge_list(u).end(); + found = (i != end); + if (found) + return std::make_pair(edge_descriptor(u, v, &(*i).get_property()), + true); + else + return std::make_pair(edge_descriptor(u, v, 0), false); + } + }; + + template + inline std::pair + adjacent_vertices(typename Config::vertex_descriptor u, + const adj_list_helper& g_) + { + typedef typename Config::graph_type AdjList; + const AdjList& cg = static_cast(g_); + AdjList& g = const_cast(cg); + typedef typename Config::adjacency_iterator adjacency_iterator; + typename Config::out_edge_iterator first, last; + boost::tie(first, last) = out_edges(u, g); + return std::make_pair(adjacency_iterator(first, &g), + adjacency_iterator(last, &g)); + } + template + inline std::pair + inv_adjacent_vertices(typename Config::vertex_descriptor u, + const adj_list_helper& g_) + { + typedef typename Config::graph_type AdjList; + const AdjList& cg = static_cast(g_); + AdjList& g = const_cast(cg); + typedef typename Config::inv_adjacency_iterator inv_adjacency_iterator; + typename Config::in_edge_iterator first, last; + boost::tie(first, last) = in_edges(u, g); + return std::make_pair(inv_adjacency_iterator(first, &g), + inv_adjacency_iterator(last, &g)); + } + template + inline std::pair + out_edges(typename Config::vertex_descriptor u, + const adj_list_helper& g_) + { + typedef typename Config::graph_type AdjList; + typedef typename Config::out_edge_iterator out_edge_iterator; + const AdjList& cg = static_cast(g_); + AdjList& g = const_cast(cg); + return + std::make_pair(out_edge_iterator(g.out_edge_list(u).begin(), u), + out_edge_iterator(g.out_edge_list(u).end(), u)); + } + template + inline std::pair + vertices(const adj_list_helper& g_) + { + typedef typename Config::graph_type AdjList; + const AdjList& cg = static_cast(g_); + AdjList& g = const_cast(cg); + return std::make_pair( g.vertex_set().begin(), g.vertex_set().end() ); + } + template + inline typename Config::vertices_size_type + num_vertices(const adj_list_helper& g_) + { + typedef typename Config::graph_type AdjList; + const AdjList& g = static_cast(g_); + return g.vertex_set().size(); + } + template + inline typename Config::degree_size_type + out_degree(typename Config::vertex_descriptor u, + const adj_list_helper& g_) + { + typedef typename Config::graph_type AdjList; + const AdjList& g = static_cast(g_); + return g.out_edge_list(u).size(); + } + template + inline std::pair + edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + const adj_list_helper& g_) + { + typedef typename Config::graph_type Graph; + typedef typename Config::edge_parallel_category Cat; + const Graph& g = static_cast(g_); + return g_.edge_dispatch(g, u, v, Cat()); + } + template + inline std::pair + edge_range(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + const adj_list_helper& g_) + { + typedef typename Config::graph_type Graph; + typedef typename Config::StoredEdge StoredEdge; + const Graph& cg = static_cast(g_); + Graph& g = const_cast(cg); + typedef typename Config::out_edge_iterator out_edge_iterator; + typename Config::OutEdgeList& el = g.out_edge_list(u); + typename Config::OutEdgeList::iterator first, last; + typename Config::EdgeContainer fake_edge_container; + tie(first, last) = + std::equal_range(el.begin(), el.end(), + StoredEdge(v, fake_edge_container.end(), + &fake_edge_container)); + return std::make_pair(out_edge_iterator(first, u), + out_edge_iterator(last, u)); + } + + template + inline typename Config::degree_size_type + in_degree(typename Config::vertex_descriptor u, + const directed_edges_helper& g_) + { + typedef typename Config::graph_type Graph; + const Graph& cg = static_cast(g_); + Graph& g = const_cast(cg); + return in_edge_list(g, u).size(); + } + + namespace detail { + template + inline + typename boost::property_map::type + get_dispatch(adj_list_helper&, Property, + boost::edge_property_tag) { + typedef typename Config::graph_type Graph; + typedef typename boost::property_map::type PA; + return PA(); + } + template + inline + typename boost::property_map::const_type + get_dispatch(const adj_list_helper&, Property, + boost::edge_property_tag) { + typedef typename Config::graph_type Graph; + typedef typename boost::property_map::const_type PA; + return PA(); + } + + template + inline + typename boost::property_map::type + get_dispatch(adj_list_helper& g, Property, + boost::vertex_property_tag) { + typedef typename Config::graph_type Graph; + typedef typename boost::property_map::type PA; + return PA(&static_cast(g)); + } + template + inline + typename boost::property_map::const_type + get_dispatch(const adj_list_helper& g, Property, + boost::vertex_property_tag) { + typedef typename Config::graph_type Graph; + typedef typename boost::property_map::const_type PA; + const Graph& cg = static_cast(g); + return PA(&cg); + } + + } // namespace detail + + // Implementation of the PropertyGraph interface + template + inline + typename boost::property_map::type + get(Property p, adj_list_helper& g) { + typedef typename property_kind::type Kind; + return detail::get_dispatch(g, p, Kind()); + } + template + inline + typename boost::property_map::const_type + get(Property p, const adj_list_helper& g) { + typedef typename property_kind::type Kind; + return detail::get_dispatch(g, p, Kind()); + } + + template + inline + typename boost::property_traits< + typename boost::property_map::const_type + >::value_type + get(Property p, const adj_list_helper& g, const Key& key) { + return get(get(p, g), key); + } + + template + inline void + put(Property p, adj_list_helper& g, + const Key& key, const Value& value) + { + typedef typename Config::graph_type Graph; + typedef typename boost::property_map::type Map; + Map pmap = get(p, static_cast(g)); + put(pmap, key, value); + } + + + //========================================================================= + // Generalize Adjacency List Implementation + + struct adj_list_tag { }; + + template + class adj_list_impl + : public adj_list_helper + { + typedef typename Config::OutEdgeList OutEdgeList; + typedef typename Config::InEdgeList InEdgeList; + typedef typename Config::StoredVertexList StoredVertexList; + public: + typedef typename Config::stored_vertex stored_vertex; + typedef typename Config::EdgeContainer EdgeContainer; + typedef typename Config::vertex_descriptor vertex_descriptor; + typedef typename Config::edge_descriptor edge_descriptor; + typedef typename Config::vertex_iterator vertex_iterator; + typedef typename Config::edge_iterator edge_iterator; + typedef typename Config::edge_parallel_category edge_parallel_category; + typedef typename Config::vertices_size_type vertices_size_type; + typedef typename Config::edges_size_type edges_size_type; + typedef typename Config::degree_size_type degree_size_type; + typedef typename Config::edge_property_type edge_property_type; + typedef adj_list_tag graph_tag; + + static vertex_descriptor null_vertex() + { + return 0; + } + + inline adj_list_impl() { } + + inline adj_list_impl(const adj_list_impl& x) { + copy_impl(x); + } + inline adj_list_impl& operator=(const adj_list_impl& x) { + this->clear(); + copy_impl(x); + return *this; + } + inline void clear() { + for (typename StoredVertexList::iterator i = m_vertices.begin(); + i != m_vertices.end(); ++i) + delete (stored_vertex*)*i; + m_vertices.clear(); + m_edges.clear(); + } + inline adj_list_impl(vertices_size_type num_vertices) { + for (vertices_size_type i = 0; i < num_vertices; ++i) + add_vertex(static_cast(*this)); + } + template + inline adj_list_impl(vertices_size_type num_vertices, + EdgeIterator first, EdgeIterator last) + { + vertex_descriptor* v = new vertex_descriptor[num_vertices]; + for (vertices_size_type i = 0; i < num_vertices; ++i) + v[i] = add_vertex(static_cast(*this)); + + while (first != last) { + add_edge(v[(*first).first], v[(*first).second], *this); + ++first; + } + delete [] v; + } + template + inline adj_list_impl(vertices_size_type num_vertices, + EdgeIterator first, EdgeIterator last, + EdgePropertyIterator ep_iter) + { + vertex_descriptor* v = new vertex_descriptor[num_vertices]; + for (vertices_size_type i = 0; i < num_vertices; ++i) + v[i] = add_vertex(static_cast(*this)); + + while (first != last) { + add_edge(v[(*first).first], v[(*first).second], *ep_iter, *this); + ++first; + ++ep_iter; + } + delete [] v; + } + ~adj_list_impl() { + for (typename StoredVertexList::iterator i = m_vertices.begin(); + i != m_vertices.end(); ++i) + delete (stored_vertex*)*i; + } + // protected: + inline OutEdgeList& out_edge_list(vertex_descriptor v) { + stored_vertex* sv = (stored_vertex*)v; + return sv->m_out_edges; + } + inline const OutEdgeList& out_edge_list(vertex_descriptor v) const { + stored_vertex* sv = (stored_vertex*)v; + return sv->m_out_edges; + } + inline StoredVertexList& vertex_set() { return m_vertices; } + inline const StoredVertexList& vertex_set() const { return m_vertices; } + + inline void copy_impl(const adj_list_impl& x_) + { + const Derived& x = static_cast(x_); + + // Would be better to have a constant time way to get from + // vertices in x to the corresponding vertices in *this. + std::map vertex_map; + + // Copy the stored vertex objects by adding each vertex + // and copying its property object. + vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(x); vi != vi_end; ++vi) { + stored_vertex* v = (stored_vertex*)add_vertex(*this); + v->m_property = ((stored_vertex*)*vi)->m_property; + vertex_map[(stored_vertex*)*vi] = v; + } + // Copy the edges by adding each edge and copying its + // property object. + edge_iterator ei, ei_end; + for (tie(ei, ei_end) = edges(x); ei != ei_end; ++ei) { + edge_descriptor e; + bool inserted; + vertex_descriptor s = source(*ei,x), t = target(*ei,x); + tie(e, inserted) = add_edge(vertex_map[(stored_vertex*)s], + vertex_map[(stored_vertex*)t], *this); + *((edge_property_type*)e.m_eproperty) + = *((edge_property_type*)(*ei).m_eproperty); + } + } + + + typename Config::EdgeContainer m_edges; + StoredVertexList m_vertices; + }; + + // O(1) + template + inline typename Config::vertex_descriptor + add_vertex(adj_list_impl& g_) + { + Derived& g = static_cast(g_); + typedef typename Config::stored_vertex stored_vertex; + stored_vertex* v = new stored_vertex; + typename Config::StoredVertexList::iterator pos; + bool inserted; + boost::tie(pos,inserted) = boost::graph_detail::push(g.m_vertices, v); + v->m_position = pos; + return v; + } + // O(1) + template + inline typename Config::vertex_descriptor + add_vertex(const typename Config::vertex_property_type& p, + adj_list_impl& g_) + { + Derived& g = static_cast(g_); + typedef typename Config::stored_vertex stored_vertex; + stored_vertex* v = new stored_vertex(p); + typename Config::StoredVertexList::iterator pos; + bool inserted; + boost::tie(pos,inserted) = boost::graph_detail::push(g.m_vertices, v); + v->m_position = pos; + return v; + } + // O(1) + template + inline void remove_vertex(typename Config::vertex_descriptor u, + adj_list_impl& g_) + { + typedef typename Config::stored_vertex stored_vertex; + Derived& g = static_cast(g_); + stored_vertex* su = (stored_vertex*)u; + g.m_vertices.erase(su->m_position); + delete su; + } + // O(V) + template + inline typename Config::vertex_descriptor + vertex(typename Config::vertices_size_type n, + const adj_list_impl& g_) + { + const Derived& g = static_cast(g_); + typename Config::vertex_iterator i = vertices(g).first; + while (n--) ++i; // std::advance(i, n); (not VC++ portable) + return *i; + } + + //========================================================================= + // Vector-Backbone Adjacency List Implementation + + namespace detail { + + template + inline void + remove_vertex_dispatch(Graph& g, vertex_descriptor u, + boost::directed_tag) + { + typedef typename Graph::edge_parallel_category edge_parallel_category; + g.m_vertices.erase(g.m_vertices.begin() + u); + vertex_descriptor V = num_vertices(g); + if (u != V) { + for (vertex_descriptor v = 0; v < V; ++v) + reindex_edge_list(g.out_edge_list(v), u, edge_parallel_category()); + } + } + + template + inline void + remove_vertex_dispatch(Graph& g, vertex_descriptor u, + boost::undirected_tag) + { + typedef typename Graph::edge_parallel_category edge_parallel_category; + g.m_vertices.erase(g.m_vertices.begin() + u); + vertex_descriptor V = num_vertices(g); + for (vertex_descriptor v = 0; v < V; ++v) + reindex_edge_list(g.out_edge_list(v), u, + edge_parallel_category()); + typedef typename Graph::EdgeContainer Container; + typedef typename Container::iterator Iter; + Iter ei = g.m_edges.begin(), ei_end = g.m_edges.end(); + for (; ei != ei_end; ++ei) { + if (ei->m_source > u) + --ei->m_source; + if (ei->m_target > u) + --ei->m_target; + } + } + template + inline void + remove_vertex_dispatch(Graph& g, vertex_descriptor u, + boost::bidirectional_tag) + { + typedef typename Graph::edge_parallel_category edge_parallel_category; + g.m_vertices.erase(g.m_vertices.begin() + u); + vertex_descriptor V = num_vertices(g); + vertex_descriptor v; + if (u != V) { + for (v = 0; v < V; ++v) + reindex_edge_list(g.out_edge_list(v), u, + edge_parallel_category()); + for (v = 0; v < V; ++v) + reindex_edge_list(in_edge_list(g, v), u, + edge_parallel_category()); + + typedef typename Graph::EdgeContainer Container; + typedef typename Container::iterator Iter; + Iter ei = g.m_edges.begin(), ei_end = g.m_edges.end(); + for (; ei != ei_end; ++ei) { + if (ei->m_source > u) + --ei->m_source; + if (ei->m_target > u) + --ei->m_target; + } + } + } + + template + inline void + reindex_edge_list(EdgeList& el, vertex_descriptor u, + boost::allow_parallel_edge_tag) + { + typename EdgeList::iterator ei = el.begin(), e_end = el.end(); + for (; ei != e_end; ++ei) + if ((*ei).get_target() > u) + --(*ei).get_target(); + } + template + inline void + reindex_edge_list(EdgeList& el, vertex_descriptor u, + boost::disallow_parallel_edge_tag) + { + typename EdgeList::iterator ei = el.begin(), e_end = el.end(); + while (ei != e_end) { + typename EdgeList::value_type ce = *ei; + ++ei; + if (ce.get_target() > u) { + el.erase(ce); + --ce.get_target(); + el.insert(ce); + } + } + } + } // namespace detail + + struct vec_adj_list_tag { }; + + template + class vec_adj_list_impl + : public adj_list_helper + { + typedef typename Config::OutEdgeList OutEdgeList; + typedef typename Config::InEdgeList InEdgeList; + typedef typename Config::StoredVertexList StoredVertexList; + public: + typedef typename Config::vertex_descriptor vertex_descriptor; + typedef typename Config::edge_descriptor edge_descriptor; + typedef typename Config::out_edge_iterator out_edge_iterator; + typedef typename Config::edge_iterator edge_iterator; + typedef typename Config::directed_category directed_category; + typedef typename Config::vertices_size_type vertices_size_type; + typedef typename Config::edges_size_type edges_size_type; + typedef typename Config::degree_size_type degree_size_type; + typedef typename Config::StoredEdge StoredEdge; + typedef typename Config::stored_vertex stored_vertex; + typedef typename Config::EdgeContainer EdgeContainer; + typedef typename Config::edge_property_type edge_property_type; + typedef vec_adj_list_tag graph_tag; + + static vertex_descriptor null_vertex() + { + return (std::numeric_limits::max)(); + } + + inline vec_adj_list_impl() { } + + inline vec_adj_list_impl(const vec_adj_list_impl& x) { + copy_impl(x); + } + inline vec_adj_list_impl& operator=(const vec_adj_list_impl& x) { + this->clear(); + copy_impl(x); + return *this; + } + inline void clear() { + m_vertices.clear(); + m_edges.clear(); + } + + inline vec_adj_list_impl(vertices_size_type _num_vertices) + : m_vertices(_num_vertices) { } + + template + inline vec_adj_list_impl(vertices_size_type num_vertices, + EdgeIterator first, EdgeIterator last) + : m_vertices(num_vertices) + { + while (first != last) { + add_edge((*first).first, (*first).second, + static_cast(*this)); + ++first; + } + } + template + inline vec_adj_list_impl(vertices_size_type num_vertices, + EdgeIterator first, EdgeIterator last, + EdgePropertyIterator ep_iter) + : m_vertices(num_vertices) + { + while (first != last) { + add_edge((*first).first, (*first).second, *ep_iter, + static_cast(*this)); + ++first; + ++ep_iter; + } + } + + // protected: + inline boost::integer_range vertex_set() const { + return boost::integer_range(0, m_vertices.size()); + } + inline OutEdgeList& out_edge_list(vertex_descriptor v) { + return m_vertices[v].m_out_edges; + } + inline const OutEdgeList& out_edge_list(vertex_descriptor v) const { + return m_vertices[v].m_out_edges; + } + inline void copy_impl(const vec_adj_list_impl& x_) + { + const Graph& x = static_cast(x_); + // Copy the stored vertex objects by adding each vertex + // and copying its property object. + for (vertices_size_type i = 0; i < num_vertices(x); ++i) { + vertex_descriptor v = add_vertex(*this); + m_vertices[v].m_property = x.m_vertices[i].m_property; + } + // Copy the edges by adding each edge and copying its + // property object. + edge_iterator ei, ei_end; + for (tie(ei, ei_end) = edges(x); ei != ei_end; ++ei) { + edge_descriptor e; + bool inserted; + tie(e, inserted) = add_edge(source(*ei,x), target(*ei,x) , *this); + *((edge_property_type*)e.m_eproperty) + = *((edge_property_type*)(*ei).m_eproperty); + } + } + typename Config::EdgeContainer m_edges; + StoredVertexList m_vertices; + }; + // Had to make these non-members to avoid accidental instantiation + // on SGI MIPSpro C++ + template + inline typename C::InEdgeList& + in_edge_list(vec_adj_list_impl& g, + typename C::vertex_descriptor v) { + return g.m_vertices[v].m_in_edges; + } + template + inline const typename C::InEdgeList& + in_edge_list(const vec_adj_list_impl& g, + typename C::vertex_descriptor v) { + return g.m_vertices[v].m_in_edges; + } + + // O(1) + template + inline typename Config::vertex_descriptor + add_vertex(vec_adj_list_impl& g_) { + Graph& g = static_cast(g_); + g.m_vertices.resize(g.m_vertices.size() + 1); + return g.m_vertices.size() - 1; + } + + template + inline typename Config::vertex_descriptor + add_vertex(const typename Config::vertex_property_type& p, + vec_adj_list_impl& g_) { + Graph& g = static_cast(g_); + typedef typename Config::stored_vertex stored_vertex; + g.m_vertices.push_back(stored_vertex(p)); + return g.m_vertices.size() - 1; + } + + // Here we override the directed_graph_helper add_edge() function + // so that the number of vertices is automatically changed if + // either u or v is greater than the number of vertices. + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + const typename Config::edge_property_type& p, + vec_adj_list_impl& g_) + { + BOOST_USING_STD_MAX(); + typename Config::vertex_descriptor x = max BOOST_PREVENT_MACRO_SUBSTITUTION(u, v); + if (x >= num_vertices(g_)) + g_.m_vertices.resize(x + 1); + adj_list_helper& g = g_; + return add_edge(u, v, p, g); + } + template + inline std::pair + add_edge(typename Config::vertex_descriptor u, + typename Config::vertex_descriptor v, + vec_adj_list_impl& g_) + { + typename Config::edge_property_type p; + return add_edge(u, v, p, g_); + } + + + // O(V + E) + template + inline void remove_vertex(typename Config::vertex_descriptor v, + vec_adj_list_impl& g_) + { + typedef typename Config::directed_category Cat; + Graph& g = static_cast(g_); + detail::remove_vertex_dispatch(g, v, Cat()); + } + // O(1) + template + inline typename Config::vertex_descriptor + vertex(typename Config::vertices_size_type n, + const vec_adj_list_impl&) + { + return n; + } + + + namespace detail { + + //========================================================================= + // Adjacency List Generator + + template + struct adj_list_gen + { + typedef typename detail::is_random_access::type + is_rand_access; + typedef typename has_property::type has_edge_property; + typedef typename DirectedS::is_directed_t DirectedT; + typedef typename DirectedS::is_bidir_t BidirectionalT; + + struct config + { + typedef OutEdgeListS edgelist_selector; + + typedef Graph graph_type; + typedef EdgeProperty edge_property_type; + typedef VertexProperty vertex_property_type; + typedef GraphProperty graph_property_type; + typedef std::size_t vertices_size_type; + + typedef adjacency_list_traits + Traits; + + typedef typename Traits::directed_category directed_category; + typedef typename Traits::edge_parallel_category edge_parallel_category; + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + + typedef void* vertex_ptr; + + // need to reorganize this to avoid instantiating stuff + // that doesn't get used -JGS + + // VertexList and vertex_iterator + typedef typename container_gen::type SeqVertexList; + typedef boost::integer_range RandVertexList; + typedef typename boost::ct_if_t::type VertexList; + + typedef typename VertexList::iterator vertex_iterator; + + // EdgeContainer and StoredEdge + + typedef typename container_gen >::type EdgeContainer; + + typedef typename ct_and::type >::type on_edge_storage; + + typedef typename boost::ct_if_t::type edges_size_type; + + typedef typename EdgeContainer::iterator EdgeIter; + + typedef typename detail::is_random_access::type is_edge_ra; + + typedef typename boost::ct_if_t, + typename boost::ct_if_t, + stored_edge_iter + >::type + >::type StoredEdge; + + // Adjacency Types + + typedef typename container_gen::type + OutEdgeList; + typedef typename OutEdgeList::size_type degree_size_type; + typedef typename OutEdgeList::iterator OutEdgeIter; + + typedef boost::detail::iterator_traits OutEdgeIterTraits; + typedef typename OutEdgeIterTraits::iterator_category OutEdgeIterCat; + typedef typename OutEdgeIterTraits::difference_type OutEdgeIterDiff; + + typedef out_edge_iter< + OutEdgeIter, vertex_descriptor, edge_descriptor, OutEdgeIterDiff + > out_edge_iterator; + + typedef typename adjacency_iterator_generator::type adjacency_iterator; + + typedef OutEdgeList InEdgeList; + typedef OutEdgeIter InEdgeIter; + typedef OutEdgeIterCat InEdgeIterCat; + typedef OutEdgeIterDiff InEdgeIterDiff; + + typedef in_edge_iter< + InEdgeIter, vertex_descriptor, edge_descriptor, InEdgeIterDiff + > in_edge_iterator; + + typedef typename inv_adjacency_iterator_generator::type inv_adjacency_iterator; + + // Edge Iterator + + typedef boost::detail::iterator_traits EdgeIterTraits; + typedef typename EdgeIterTraits::iterator_category EdgeIterCat; + typedef typename EdgeIterTraits::difference_type EdgeIterDiff; + + typedef undirected_edge_iter< + EdgeIter + , edge_descriptor + , EdgeIterDiff + > UndirectedEdgeIter; // also used for bidirectional + + typedef adj_list_edge_iterator DirectedEdgeIter; + + typedef typename boost::ct_if_t::type edge_iterator; + + // stored_vertex and StoredVertexList + typedef typename container_gen::type + SeqStoredVertexList; + struct seq_stored_vertex { + seq_stored_vertex() { } + seq_stored_vertex(const VertexProperty& p) : m_property(p) { } + OutEdgeList m_out_edges; + VertexProperty m_property; + typename SeqStoredVertexList::iterator m_position; + }; + struct bidir_seq_stored_vertex { + bidir_seq_stored_vertex() { } + bidir_seq_stored_vertex(const VertexProperty& p) : m_property(p) { } + OutEdgeList m_out_edges; + InEdgeList m_in_edges; + VertexProperty m_property; + typename SeqStoredVertexList::iterator m_position; + }; + struct rand_stored_vertex { + rand_stored_vertex() { } + rand_stored_vertex(const VertexProperty& p) : m_property(p) { } + OutEdgeList m_out_edges; + VertexProperty m_property; + }; + struct bidir_rand_stored_vertex { + bidir_rand_stored_vertex() { } + bidir_rand_stored_vertex(const VertexProperty& p) : m_property(p) { } + OutEdgeList m_out_edges; + InEdgeList m_in_edges; + VertexProperty m_property; + }; + typedef typename boost::ct_if_t::type, + typename boost::ct_if_t::type + >::type StoredVertex; + struct stored_vertex : public StoredVertex { + stored_vertex() { } + stored_vertex(const VertexProperty& p) : StoredVertex(p) { } + }; + + typedef typename container_gen::type + RandStoredVertexList; + typedef typename boost::ct_if_t< is_rand_access, + RandStoredVertexList, SeqStoredVertexList>::type StoredVertexList; + }; // end of config + + + typedef typename boost::ct_if_t, + typename boost::ct_if_t, + undirected_graph_helper + >::type + >::type DirectedHelper; + + typedef typename boost::ct_if_t, + adj_list_impl + >::type type; + + }; + + } // namespace detail + + //========================================================================= + // Vertex Property Maps + + template + struct adj_list_vertex_property_map + : public boost::put_get_helper< + Reference, + adj_list_vertex_property_map + > + { + typedef typename Graph::stored_vertex StoredVertex; + typedef ValueType value_type; + typedef Reference reference; + typedef typename Graph::vertex_descriptor key_type; + typedef boost::lvalue_property_map_tag category; + inline adj_list_vertex_property_map() { } + inline adj_list_vertex_property_map(const Graph*) { } + inline Reference operator[](key_type v) const { + StoredVertex* sv = (StoredVertex*)v; + return get_property_value(sv->m_property, Tag()); + } + inline Reference operator()(key_type v) const { + return this->operator[](v); + } + }; + + template + struct adj_list_vertex_all_properties_map + : public boost::put_get_helper + > + { + typedef typename Graph::stored_vertex StoredVertex; + typedef Property value_type; + typedef PropRef reference; + typedef typename Graph::vertex_descriptor key_type; + typedef boost::lvalue_property_map_tag category; + inline adj_list_vertex_all_properties_map() { } + inline adj_list_vertex_all_properties_map(const Graph*) { } + inline PropRef operator[](key_type v) const { + StoredVertex* sv = (StoredVertex*)v; + return sv->m_property; + } + inline PropRef operator()(key_type v) const { + return this->operator[](v); + } + }; + + template + struct vec_adj_list_vertex_property_map + : public boost::put_get_helper< + Reference, + vec_adj_list_vertex_property_map + > + { + typedef ValueType value_type; + typedef Reference reference; + typedef typename boost::graph_traits::vertex_descriptor key_type; + typedef boost::lvalue_property_map_tag category; + vec_adj_list_vertex_property_map() { } + vec_adj_list_vertex_property_map(GraphPtr g) : m_g(g) { } + inline Reference operator[](key_type v) const { + return get_property_value(m_g->m_vertices[v].m_property, Tag()); + } + inline Reference operator()(key_type v) const { + return this->operator[](v); + } + GraphPtr m_g; + }; + + template + struct vec_adj_list_vertex_all_properties_map + : public boost::put_get_helper + > + { + typedef Property value_type; + typedef PropertyRef reference; + typedef typename boost::graph_traits::vertex_descriptor key_type; + typedef boost::lvalue_property_map_tag category; + vec_adj_list_vertex_all_properties_map() { } + vec_adj_list_vertex_all_properties_map(GraphPtr g) : m_g(g) { } + inline PropertyRef operator[](key_type v) const { + return m_g->m_vertices[v].m_property; + } + inline PropertyRef operator()(key_type v) const { + return this->operator[](v); + } + GraphPtr m_g; + }; + + struct adj_list_any_vertex_pa { + template + struct bind_ { + typedef typename property_value::type value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + + typedef adj_list_vertex_property_map + type; + typedef adj_list_vertex_property_map + const_type; + }; + }; + struct adj_list_all_vertex_pa { + template + struct bind_ { + typedef typename Graph::vertex_descriptor Vertex; + typedef adj_list_vertex_all_properties_map type; + typedef adj_list_vertex_all_properties_map const_type; + }; + }; + + template + struct vec_adj_list_vertex_id_map + : public boost::put_get_helper< + Vertex, vec_adj_list_vertex_id_map + > + { + typedef Vertex value_type; + typedef Vertex key_type; + typedef Vertex reference; + typedef boost::readable_property_map_tag category; + inline vec_adj_list_vertex_id_map() { } + template + inline vec_adj_list_vertex_id_map(const Graph&) { } + inline value_type operator[](key_type v) const { return v; } + inline value_type operator()(key_type v) const { return v; } + }; + + struct vec_adj_list_any_vertex_pa { + template + struct bind_ { + typedef typename property_value::type value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + + typedef vec_adj_list_vertex_property_map + type; + typedef vec_adj_list_vertex_property_map + const_type; + }; + }; + struct vec_adj_list_id_vertex_pa { + template + struct bind_ { + typedef typename Graph::vertex_descriptor Vertex; + typedef vec_adj_list_vertex_id_map type; + typedef vec_adj_list_vertex_id_map const_type; + }; + }; + struct vec_adj_list_all_vertex_pa { + template + struct bind_ { + typedef typename Graph::vertex_descriptor Vertex; + typedef vec_adj_list_vertex_all_properties_map + type; + typedef vec_adj_list_vertex_all_properties_map + const_type; + }; + }; + namespace detail { + template + struct adj_list_choose_vertex_pa_helper { + typedef adj_list_any_vertex_pa type; + }; + template <> + struct adj_list_choose_vertex_pa_helper { + typedef adj_list_all_vertex_pa type; + }; + template + struct adj_list_choose_vertex_pa { + typedef typename adj_list_choose_vertex_pa_helper::type Helper; + typedef typename Helper::template bind_ Bind; + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + + + template + struct vec_adj_list_choose_vertex_pa_helper { + typedef vec_adj_list_any_vertex_pa type; + }; + template <> + struct vec_adj_list_choose_vertex_pa_helper { + typedef vec_adj_list_id_vertex_pa type; + }; + template <> + struct vec_adj_list_choose_vertex_pa_helper { + typedef vec_adj_list_all_vertex_pa type; + }; + template + struct vec_adj_list_choose_vertex_pa { + typedef typename vec_adj_list_choose_vertex_pa_helper::type Helper; + typedef typename Helper::template bind_ Bind; + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + } // namespace detail + + //========================================================================= + // Edge Property Map + + template + struct adj_list_edge_property_map + : public put_get_helper< + Ref, + adj_list_edge_property_map + > + { + typedef Value value_type; + typedef Ref reference; + typedef detail::edge_desc_impl key_type; + typedef boost::lvalue_property_map_tag category; + inline Ref operator[](key_type e) const { + Property& p = *(Property*)e.get_property(); + return get_property_value(p, Tag()); + } + inline Ref operator()(key_type e) const { + return this->operator[](e); + } + }; + + template + struct adj_list_edge_all_properties_map + : public put_get_helper + > + { + typedef Property value_type; + typedef PropRef reference; + typedef detail::edge_desc_impl key_type; + typedef boost::lvalue_property_map_tag category; + inline PropRef operator[](key_type e) const { + return *(PropPtr)e.get_property(); + } + inline PropRef operator()(key_type e) const { + return this->operator[](e); + } + }; + + // Edge Property Maps + + namespace detail { + struct adj_list_any_edge_pmap { + template + struct bind_ { + typedef typename property_value::type value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + + typedef adj_list_edge_property_map + type; + typedef adj_list_edge_property_map + const_type; + }; + }; + struct adj_list_all_edge_pmap { + template + struct bind_ { + typedef adj_list_edge_all_properties_map + type; + typedef adj_list_edge_all_properties_map + const_type; + }; + }; + + template + struct adj_list_choose_edge_pmap_helper { + typedef adj_list_any_edge_pmap type; + }; + template <> + struct adj_list_choose_edge_pmap_helper { + typedef adj_list_all_edge_pmap type; + }; + template + struct adj_list_choose_edge_pmap { + typedef typename adj_list_choose_edge_pmap_helper::type Helper; + typedef typename Helper::template bind_ Bind; + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + struct adj_list_edge_property_selector { + template + struct bind_ { + typedef adj_list_choose_edge_pmap Choice; + typedef typename Choice::type type; + typedef typename Choice::const_type const_type; + }; + }; + } // namespace detail + + template <> + struct edge_property_selector { + typedef detail::adj_list_edge_property_selector type; + }; + template <> + struct edge_property_selector { + typedef detail::adj_list_edge_property_selector type; + }; + + // Vertex Property Maps + + struct adj_list_vertex_property_selector { + template + struct bind_ { + typedef detail::adj_list_choose_vertex_pa Choice; + typedef typename Choice::type type; + typedef typename Choice::const_type const_type; + }; + }; + template <> + struct vertex_property_selector { + typedef adj_list_vertex_property_selector type; + }; + + struct vec_adj_list_vertex_property_selector { + template + struct bind_ { + typedef detail::vec_adj_list_choose_vertex_pa Choice; + typedef typename Choice::type type; + typedef typename Choice::const_type const_type; + }; + }; + template <> + struct vertex_property_selector { + typedef vec_adj_list_vertex_property_selector type; + }; + +} // namespace boost + +#if !defined(BOOST_NO_HASH) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +namespace BOOST_STD_EXTENSION_NAMESPACE { + + #if BOOST_WORKAROUND( _STLPORT_VERSION, >= 0x500 ) + // STLport 5 already defines a hash specialization. + #else + template <> + struct hash< void* > // Need this when vertex_descriptor=void* + { + std::size_t + operator()(void* v) const { return (std::size_t)v; } + }; + #endif + + template + struct hash< boost::detail::stored_edge > + { + std::size_t + operator()(const boost::detail::stored_edge& e) const + { + return hash()(e.m_target); + } + }; + + template + struct hash< boost::detail::stored_edge_property > + { + std::size_t + operator()(const boost::detail::stored_edge_property& e) const + { + return hash()(e.m_target); + } + }; + + template + struct hash< boost::detail::stored_edge_iter > + { + std::size_t + operator()(const boost::detail::stored_edge_iter& e) const + { + return hash()(e.m_target); + } + }; + +} +#endif + + +#undef stored_edge +#undef stored_edge_property +#undef stored_edge_iter + +#endif // BOOST_GRAPH_DETAIL_DETAIL_ADJACENCY_LIST_CCT + +/* + Implementation Notes: + + Many of the public interface functions in this file would have been + more conveniently implemented as inline friend functions. + However there are a few compiler bugs that make that approach + non-portable. + + 1. g++ inline friend in namespace bug + 2. g++ using clause doesn't work with inline friends + 3. VC++ doesn't have Koenig lookup + + For these reasons, the functions were all written as non-inline free + functions, and static cast was used to convert from the helper + class to the adjacency_list derived class. + + Looking back, it might have been better to write out all functions + in terms of the adjacency_list, and then use a tag to dispatch + to the various helpers instead of using inheritance. + + */ diff --git a/deal.II/contrib/boost/include/boost/graph/detail/array_binary_tree.hpp b/deal.II/contrib/boost/include/boost/graph/detail/array_binary_tree.hpp new file mode 100644 index 0000000000..30e022efbc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/array_binary_tree.hpp @@ -0,0 +1,180 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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 ADSTL_ARRAY_BINARY_TREE_HPP +#define ADSTL_ARRAY_BINARY_TREE_HPP + +#include +#include +#include + +namespace adstl { + /* + Note: array_binary_tree is a completey balanced binary tree + */ + +#if !defined BOOST_NO_STD_ITERATOR_TRAITS + template +#else + template +#endif +class array_binary_tree_node { +public: + typedef array_binary_tree_node ArrayBinaryTreeNode; + typedef RandomAccessIterator rep_iterator; +#if !defined BOOST_NO_STD_ITERATOR_TRAITS + typedef typename std::iterator_traits::difference_type + difference_type; + typedef typename std::iterator_traits::value_type + value_type; +#else + typedef int difference_type; + typedef ValueType value_type; +#endif + typedef difference_type size_type; + + struct children_type { + struct iterator + : boost::iterator + { // replace with iterator_adaptor implementation -JGS + + inline iterator() : i(0), n(0) { } + inline iterator(const iterator& x) : r(x.r), i(x.i), n(x.n), id(x.id) { } + inline iterator& operator=(const iterator& x) { + r = x.r; i = x.i; n = x.n; + /*egcs generate a warning*/ + id = x.id; + return *this; + } + inline iterator(rep_iterator rr, + size_type ii, + size_type nn, + const ID& _id) : r(rr), i(ii), n(nn), id(_id) { } + inline array_binary_tree_node operator*() { + return ArrayBinaryTreeNode(r, i, n, id); } + inline iterator& operator++() { ++i; return *this; } + inline iterator operator++(int) + { iterator t = *this; ++(*this); return t; } + inline bool operator==(const iterator& x) const { return i == x.i; } + inline bool operator!=(const iterator& x) const + { return !(*this == x); } + rep_iterator r; + size_type i; + size_type n; + ID id; + }; + inline children_type() : i(0), n(0) { } + inline children_type(const children_type& x) + : r(x.r), i(x.i), n(x.n), id(x.id) { } + inline children_type& operator=(const children_type& x) { + r = x.r; i = x.i; n = x.n; + /*egcs generate a warning*/ + id = x.id; + return *this; + } + inline children_type(rep_iterator rr, + size_type ii, + size_type nn, + const ID& _id) : r(rr), i(ii), n(nn), id(_id) { } + inline iterator begin() { return iterator(r, 2 * i + 1, n, id); } + inline iterator end() { return iterator(r, 2 * i + 1 + size(), n, id); } + inline size_type size() const { + size_type c = 2 * i + 1; + size_type s; + if (c + 1 < n) s = 2; + else if (c < n) s = 1; + else s = 0; + return s; + } + rep_iterator r; + size_type i; + size_type n; + ID id; + }; + inline array_binary_tree_node() : i(0), n(0) { } + inline array_binary_tree_node(const array_binary_tree_node& x) + : r(x.r), i(x.i), n(x.n), id(x.id) { } + inline ArrayBinaryTreeNode& operator=(const ArrayBinaryTreeNode& x) { + r = x.r; + i = x.i; + n = x.n; + /*egcs generate a warning*/ + id = x.id; + return *this; + } + inline array_binary_tree_node(rep_iterator start, + rep_iterator end, + rep_iterator pos, const ID& _id) + : r(start), i(pos - start), n(end - start), id(_id) { } + inline array_binary_tree_node(rep_iterator rr, + size_type ii, + size_type nn, const ID& _id) + : r(rr), i(ii), n(nn), id(_id) { } + inline value_type& value() { return *(r + i); } + inline const value_type& value() const { return *(r + i); } + inline ArrayBinaryTreeNode parent() const { + return ArrayBinaryTreeNode(r, (i - 1) / 2, n, id); + } + inline bool has_parent() const { return i != 0; } + inline children_type children() { return children_type(r, i, n, id); } + /* + inline void swap(array_binary_tree_node x) { + value_type tmp = x.value(); + x.value() = value(); + value() = tmp; + i = x.i; + } + */ + template + inline void swap(ArrayBinaryTreeNode x, ExternalData& edata ) { + value_type tmp = x.value(); + + /*swap external data*/ + edata[ boost::get(id, tmp) ] = i; + edata[ boost::get(id, value()) ] = x.i; + + x.value() = value(); + value() = tmp; + i = x.i; + } + inline const children_type children() const { + return children_type(r, i, n); + } + inline size_type index() const { return i; } + rep_iterator r; + size_type i; + size_type n; + ID id; +}; + +template > +struct compare_array_node { + typedef typename RandomAccessContainer::value_type value_type; + compare_array_node(const Compare& x) : comp(x) {} + compare_array_node(const compare_array_node& x) : comp(x.comp) {} + + template< class node_type > + inline bool operator()(const node_type& x, const node_type& y) { + return comp(x.value(), y.value()); + } + + template< class node_type > + inline bool operator()(const node_type& x, const node_type& y) const { + return comp(x.value(), y.value()); + } + Compare comp; +}; + + +} /* namespace adstl */ + +#endif /* ADSTL_ARRAY_BINARY_TREE_H */ diff --git a/deal.II/contrib/boost/include/boost/graph/detail/bitset.hpp b/deal.II/contrib/boost/include/boost/graph/detail/bitset.hpp new file mode 100644 index 0000000000..c09c47b16c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/bitset.hpp @@ -0,0 +1,907 @@ +// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. + +/* + * Copyright (c) 1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +// This provides versions of std::bitset with both static and dynamic size. + +// UNDER CONSTRUCTION + + +// replace this later +#include +#define BOOST_ASSERT_THROW(expr, except) assert(expr) + +namespace boost { + + namespace detail { + // structure to aid in counting bits + template + struct bit_count { + static unsigned char value[256]; + }; + + // Mapping from 8 bit unsigned integers to the index of the first bit + template + struct first_bit_location { + static unsigned char value[256]; + }; + + template // this size is in bits + struct word_traits { + typedef WordType word_type; + static const std::size_t word_size = CHAR_BIT * sizeof(word_type); + }; + + //========================================================================= + template + class bitset_base + : public bitset_adaptor< SizeType, + bitset_base > + { + // private: + public: + typedef SizeType size_type; + typedef typename WordTraits::word_type word_type; + + static size_type s_which_word(size_type pos) { + return pos / WordTraits::word_size; + } + static size_type s_which_byte(size_type pos) { + return (pos % WordTraits::word_size) / CHAR_BIT; + } + static size_type s_which_bit(size_type pos) { + return pos % WordTraits::word_size; + } + static word_type s_mask_bit(size_type pos) { + return (static_cast(1)) << s_which_bit(pos); + } + word_type& m_get_word(size_type pos) { + return data()[s_which_word(pos)]; + } + word_type m_get_word(size_type pos) const { + return data()[s_which_word(pos)]; + } + word_type& m_hi_word() { return data()[num_words() - 1]; } + word_type m_hi_word() const { return data()[num_words() - 1]; } + + void m_sanitize_highest() { + size_type extra_bits = size() % WordTraits::word_size; + if (extra_bits) + m_hi_word() &= ~((~static_cast(0)) << extra_bits); + } + public: + + class reference { + friend class bitset_base; + + word_type *m_word_ptr; + size_type m_bit_pos; + + // left undefined + reference(); + + reference(bitset_base& b, size_type pos ) { + m_word_ptr = &b.m_get_word(pos); + m_bit_pos = s_which_bit(pos); + } + + public: + ~reference() {} + + // for b[i] = x; + reference& operator=(bool x) { + if ( x ) + *m_word_ptr |= s_mask_bit(m_bit_pos); + else + *m_word_ptr &= ~s_mask_bit(m_bit_pos); + + return *this; + } + // for b[i] = b[j]; + reference& operator=(const reference& j) { + if ( (*(j.m_word_ptr) & s_mask_bit(j.m_bit_pos)) ) + *m_word_ptr |= s_mask_bit(m_bit_pos); + else + *m_word_ptr &= ~s_mask_bit(m_bit_pos); + + return *this; + } + // flips the bit + bool operator~() const { + return (*(m_word_ptr) & s_mask_bit(m_bit_pos)) == 0; + } + // for x = b[i]; + operator bool() const { + return (*(m_word_ptr) & s_mask_bit(m_bit_pos)) != 0; + } + // for b[i].flip(); + reference& flip() { + *m_word_ptr ^= s_mask_bit(m_bit_pos); + return *this; + } + }; + + void init_from_ulong(unsigned long val) { + reset(); + const size_type n = (std::min)(sizeof(unsigned long) * CHAR_BIT, + WordTraits::word_size * num_words()); + for(size_type i = 0; i < n; ++i, val >>= 1) + if ( val & 0x1 ) + m_get_word(i) |= s_mask_bit(i); + } + + // intersection: this = this & x + Derived& operator&=(const Derived& x) { + for (size_type i = 0; i < num_words(); ++i) + data()[i] &= x.data()[i]; + return static_cast(*this); + } + // union: this = this | x + Derived& operator|=(const Derived& x) { + for (size_type i = 0; i < num_words(); ++i) + data()[i] |= x.data()[i]; + return static_cast(*this); + } + // exclusive or: this = this ^ x + Derived& operator^=(const Derived& x) { + for (size_type i = 0; i < num_words(); ++i) + data()[i] ^= x.data()[i]; + return static_cast(*this); + } + // left shift + Derived& operator<<=(size_type pos); + + // right shift + Derived& operator>>=(size_type pos); + + Derived& set() { + for (size_type i = 0; i < num_words(); ++i) + data()[i] = ~static_cast(0); + m_sanitize_highest(); + return static_cast(*this); + } + + Derived& set(size_type pos, int val = true) + { + BOOST_ASSERT_THROW(pos < size(), std::out_of_range("boost::bitset::set(pos,value)")); + if (val) + m_get_word(pos) |= s_mask_bit(pos); + else + m_get_word(pos) &= ~s_mask_bit(pos); + return static_cast(*this); + } + + Derived& reset() { + for (size_type i = 0; i < num_words(); ++i) + data()[i] = 0; + return static_cast(*this); + } + + Derived& reset(size_type pos) { + BOOST_ASSERT_THROW(pos < size(), std::out_of_range("boost::bitset::reset(pos)")); + m_get_word(pos) &= ~s_mask_bit(pos); + return static_cast(*this); + } + + // compliment + Derived operator~() const { + return Derived(static_cast(*this)).flip(); + } + + Derived& flip() { + for (size_type i = 0; i < num_words(); ++i) + data()[i] = ~data()[i]; + m_sanitize_highest(); + return static_cast(*this); + } + Derived& flip(size_type pos) { + BOOST_ASSERT_THROW(pos < size(), std::out_of_range("boost::bitset::flip(pos)")); + m_get_word(pos) ^= s_mask_bit(pos); + return static_cast(*this); + } + + // element access + reference operator[](size_type pos) { return reference(*this, pos); } + bool operator[](size_type pos) const { return test(pos); } + + unsigned long to_ulong() const; + + // to_string + + + size_type count() const { + size_type result = 0; + const unsigned char* byte_ptr = (const unsigned char*)data(); + const unsigned char* end_ptr = + (const unsigned char*)(data() + num_words()); + while ( byte_ptr < end_ptr ) { + result += bit_count<>::value[*byte_ptr]; + byte_ptr++; + } + return result; + } + + // size() must be provided by Derived class + + bool operator==(const Derived& x) const { + return std::equal(data(), data() + num_words(), x.data()); + } + + bool operator!=(const Derived& x) const { + return ! this->operator==(x); + } + + bool test(size_type pos) const { + BOOST_ASSERT_THROW(pos < size(), std::out_of_range("boost::bitset::test(pos)")); + return (m_get_word(pos) & s_mask_bit(pos)) + != static_cast(0); + } + + bool any() const { + for (size_type i = 0; i < num_words(); ++i) { + if ( data()[i] != static_cast(0) ) + return true; + } + return false; + } + bool none() const { + return !any(); + } + + Derived operator<<(size_type pos) const + { return Derived(static_cast(*this)) <<= pos; } + + Derived operator>>(size_type pos) const + { return Derived(static_cast(*this)) >>= pos; } + + template + void m_copy_from_string(const basic_string& s, + size_type pos, size_type n) + { + reset(); + const size_type nbits = (std::min)(size(), (std::min)(n, s.size() - pos)); + for (size_type i = 0; i < nbits; ++i) { + switch(s[pos + nbits - i - 1]) { + case '0': + break; + case '1': + this->set(i); + break; + default: + throw std::invalid_argument + ("boost::bitset_base::m_copy_from_string(s, pos, n)"); + } + } + } + + template + void m_copy_to_string(basic_string& s) const + { + s.assign(size(), '0'); + + for (size_type i = 0; i < size(); ++i) + if (test(i)) + s[size() - 1 - i] = '1'; + } + + //----------------------------------------------------------------------- + // Stuff not in std::bitset + + // difference: this = this - x + Derived& operator-=(const Derived& x) { + for (size_type i = 0; i < num_words(); ++i) + data()[i] &= ~x.data()[i]; + return static_cast(*this); + } + + // this wasn't working, why? + int compare_3way(const Derived& x) const { + return std::lexicographical_compare_3way + (data(), data() + num_words(), x.data(), x.data() + x.num_words()); + } + + // less-than compare + bool operator<(const Derived& x) const { + return std::lexicographical_compare + (data(), data() + num_words(), x.data(), x.data() + x.num_words()); + } + + // find the index of the first "on" bit + size_type find_first() const; + + // find the index of the next "on" bit after prev + size_type find_next(size_type prev) const; + + + size_type _Find_first() const { return find_first(); } + + // find the index of the next "on" bit after prev + size_type _Find_next(size_type prev) const { return find_next(prev); } + + // private: + word_type* data() + { return static_cast(this)->data(); } + + const word_type* data() const + { return static_cast(this)->data(); } + + size_type num_words() const + { return static_cast(this)->num_words(); } + + size_type size() const + { return static_cast(this)->size(); } + }; + + // 23.3.5.3 bitset operations: + template + inline D operator&(const bitset_base& x, + const bitset_base& y) { + D result(static_cast(x)); + result &= static_cast(y); + return result; + } + + template + inline D operator|(const bitset_base& x, + const bitset_base& y) { + D result(static_cast(x)); + result |= static_cast(y); + return result; + } + + template + inline D operator^(const bitset_base& x, + const bitset_base& y) { + D result(static_cast(x)); + result ^= static_cast(y); + return result; + } + + // this one is an extension + template + inline D operator-(const bitset_base& x, + const bitset_base& y) { + D result(static_cast(x)); + result -= static_cast(y); + return result; + } + + template + inline int compare_3way(const bitset_base& x, + const bitset_base& y) { + return std::lexicographical_compare_3way + (x.data(), x.data() + x.num_words(), + y.data(), y.data() + y.num_words()); + } + + + template + std::istream& + operator>>(std::istream& is, bitset_base& x) { + std::string tmp; + tmp.reserve(x.size()); + + // In new templatized iostreams, use istream::sentry + if (is.flags() & ios::skipws) { + char c; + do + is.get(c); + while (is && isspace(c)); + if (is) + is.putback(c); + } + + for (S i = 0; i < x.size(); ++i) { + char c; + is.get(c); + + if (!is) + break; + else if (c != '0' && c != '1') { + is.putback(c); + break; + } + else + // tmp.push_back(c); + tmp += c; + } + + if (tmp.empty()) + is.clear(is.rdstate() | ios::failbit); + else + x.m_copy_from_string(tmp, static_cast(0), x.size()); + + return is; + } + + template + std::ostream& operator<<(std::ostream& os, + const bitset_base& x) { + std::string tmp; + x.m_copy_to_string(tmp); + return os << tmp; + } + + //========================================================================= + template + > + class dyn_size_bitset + : public bitset_base, SizeType, + dyn_size_bitset > + { + typedef dyn_size_bitset self; + public: + typedef SizeType size_type; + private: + typedef word_traits WordTraits; + static const size_type word_size = WordTraits::word_size; + + public: + dyn_size_bitset(unsigned long val, + size_type n, + const Allocator& alloc = Allocator()) + : m_data(alloc.allocate((n + word_size - 1) / word_size)), + m_size(n), + m_num_words((n + word_size - 1) / word_size), + m_alloc(alloc) + { + init_from_ulong(val); + } + + dyn_size_bitset(size_type n, // size of the set's "universe" + const Allocator& alloc = Allocator()) + : m_data(alloc.allocate((n + word_size - 1) / word_size)), + m_size(n), m_num_words((n + word_size - 1) / word_size), + m_alloc(alloc) + { } + + template + explicit dyn_size_bitset + (const basic_string& s, + std::size_t pos = 0, + std::size_t n = std::size_t(basic_string::npos), + const Allocator& alloc = Allocator()) + : m_data(alloc.allocate((n + word_size - 1) / word_size)), + m_size(n), m_num_words((n + word_size - 1) / word_size), + m_alloc(alloc) + { + BOOST_ASSERT_THROW(pos < s.size(), std::out_of_range("dyn_size_bitset::dyn_size_bitset(s,pos,n,alloc)")); + m_copy_from_string(s, pos, n); + } + + template + explicit dyn_size_bitset + (InputIterator first, InputIterator last, + size_type n, // size of the set's "universe" + const Allocator& alloc = Allocator()) + : m_data(alloc.allocate((n + word_size - 1) / word_size)), + m_size(N), m_num_words((n + word_size - 1) / word_size), + m_alloc(alloc) + { + while (first != last) + this->set(*first++); + } + + ~dyn_size_bitset() { + m_alloc.deallocate(m_data, m_num_words); + } + + size_type size() const { return m_size; } + + // protected: + size_type num_words() const { return m_num_words; } + + word_type* data() { return m_data; } + const word_type* data() const { return m_data; } + + protected: + word_type* m_data; + SizeType m_size; + SizeType m_num_words; + Allocator m_alloc; + }; + + //========================================================================= + template + class bitset + : public bitset_base, SizeType, + bitset > + { + typedef bitset self; + static const std::size_t word_size = word_traits::word_size; + public: + // 23.3.5.1 constructors: + bitset() { +#if defined(__GNUC__) + for (size_type i = 0; i < num_words(); ++i) + m_data[i] = static_cast(0); +#endif + } + + bitset(unsigned long val) { + init_from_ulong(val); + } + + template + explicit bitset + (const basic_string& s, + std::size_t pos = 0, + std::size_t n = std::size_t(basic_string::npos)) + { + BOOST_ASSERT_THROW + (pos < s.size(), std::out_of_range("bitset::bitset(s,pos,n)")); + m_copy_from_string(s, pos, n); + } + + size_type size() const { return N; } + + // protected: + size_type num_words() const { return (N + word_size - 1) / word_size; } + + word_type* data() { return m_data; } + const word_type* data() const { return m_data; } + protected: + word_type m_data[(N + word_size - 1) / word_size]; + }; + + //========================================================================= + struct select_static_bitset { + template + struct bind_ { + typedef bitset type; + }; + }; + struct select_dyn_size_bitset { + template + struct bind_ { + typedef dyn_size_bitset type; + }; + }; + + template + > + class bitset_generator { + typedef typename ct_if::type selector; + public: + typedef typename selector + ::template bind_::type type; + }; + + + //========================================================================= + // bitset_base non-inline member function implementations + + template + Derived& + bitset_base:: + operator<<=(size_type shift) + { + typedef typename WordTraits::word_type word_type; + typedef SizeType size_type; + if (shift != 0) { + const size_type wshift = shift / WordTraits::word_size; + const size_type offset = shift % WordTraits::word_size; + const size_type sub_offset = WordTraits::word_size - offset; + size_type n = num_words() - 1; + for ( ; n > wshift; --n) + data()[n] = (data()[n - wshift] << offset) | + (data()[n - wshift - 1] >> sub_offset); + if (n == wshift) + data()[n] = data()[0] << offset; + for (size_type n1 = 0; n1 < n; ++n1) + data()[n1] = static_cast(0); + } + m_sanitize_highest(); + return static_cast(*this); + } // end operator<<= + + + template + Derived& + bitset_base:: + operator>>=(size_type shift) + { + typedef typename WordTraits::word_type word_type; + typedef SizeType size_type; + if (shift != 0) { + const size_type wshift = shift / WordTraits::word_size; + const size_type offset = shift % WordTraits::word_size; + const size_type sub_offset = WordTraits::word_size - offset; + const size_type limit = num_words() - wshift - 1; + size_type n = 0; + for ( ; n < limit; ++n) + data()[n] = (data()[n + wshift] >> offset) | + (data()[n + wshift + 1] << sub_offset); + data()[limit] = data()[num_words()-1] >> offset; + for (size_type n1 = limit + 1; n1 < num_words(); ++n1) + data()[n1] = static_cast(0); + } + m_sanitize_highest(); + return static_cast(*this); + } // end operator>>= + + + template + unsigned long bitset_base:: + to_ulong() const + { + typedef typename WordTraits::word_type word_type; + typedef SizeType size_type; + const std::overflow_error + overflow("boost::bit_set::operator unsigned long()"); + + if (sizeof(word_type) >= sizeof(unsigned long)) { + for (size_type i = 1; i < num_words(); ++i) + BOOST_ASSERT_THROW(! data()[i], overflow); + + const word_type mask + = static_cast(static_cast(-1)); + BOOST_ASSERT_THROW(! (data()[0] & ~mask), overflow); + + return static_cast(data()[0] & mask); + } + else { // sizeof(word_type) < sizeof(unsigned long). + const size_type nwords = + (sizeof(unsigned long) + sizeof(word_type) - 1) / sizeof(word_type); + + size_type min_nwords = nwords; + if (num_words() > nwords) { + for (size_type i = nwords; i < num_words(); ++i) + BOOST_ASSERT_THROW(!data()[i], overflow); + } + else + min_nwords = num_words(); + + // If unsigned long is 8 bytes and word_type is 6 bytes, then + // an unsigned long consists of all of one word plus 2 bytes + // from another word. + const size_type part = sizeof(unsigned long) % sizeof(word_type); + +#if 0 + // bug in here? + // >> to far? + BOOST_ASSERT_THROW((part != 0 + && nwords <= num_words() + && (data()[min_nwords - 1] >> + ((sizeof(word_type) - part) * CHAR_BIT)) != 0), + overflow); +#endif + + unsigned long result = 0; + for (size_type i = 0; i < min_nwords; ++i) { + result |= static_cast( + data()[i]) << (i * sizeof(word_type) * CHAR_BIT); + } + return result; + } + }// end operator unsigned long() + + + template + SizeType bitset_base:: + find_first() const + { + SizeType not_found = size(); + for (size_type i = 0; i < num_words(); i++ ) { + word_type thisword = data()[i]; + if ( thisword != static_cast(0) ) { + // find byte within word + for ( std::size_t j = 0; j < sizeof(word_type); j++ ) { + unsigned char this_byte + = static_cast(thisword & (~(unsigned char)0)); + if ( this_byte ) + return i * WordTraits::word_size + j * CHAR_BIT + + first_bit_location<>::value[this_byte]; + + thisword >>= CHAR_BIT; + } + } + } + // not found, so return an indication of failure. + return not_found; + } + + template + SizeType bitset_base:: + bitset_base:: + find_next(size_type prev) const + { + SizeType not_found = size(); + // make bound inclusive + ++prev; + + // check out of bounds + if ( prev >= num_words() * WordTraits::word_size ) + return not_found; + + // search first word + size_type i = s_which_word(prev); + word_type thisword = data()[i]; + + // mask off bits below bound + thisword &= (~static_cast(0)) << s_which_bit(prev); + + if ( thisword != static_cast(0) ) { + // find byte within word + // get first byte into place + thisword >>= s_which_byte(prev) * CHAR_BIT; + for ( size_type j = s_which_byte(prev); j < sizeof(word_type); j++ ) { + unsigned char this_byte + = static_cast(thisword & (~(unsigned char)0)); + if ( this_byte ) + return i * WordTraits::word_size + j * CHAR_BIT + + first_bit_location<>::value[this_byte]; + + thisword >>= CHAR_BIT; + } + } + + // check subsequent words + i++; + for ( ; i < num_words(); i++ ) { + word_type thisword = data()[i]; + if ( thisword != static_cast(0) ) { + // find byte within word + for ( size_type j = 0; j < sizeof(word_type); j++ ) { + unsigned char this_byte + = static_cast(thisword & (~(unsigned char)0)); + if ( this_byte ) + return i * WordTraits::word_size + j * CHAR_BIT + + first_bit_location<>::value[this_byte]; + + thisword >>= CHAR_BIT; + } + } + } + + // not found, so return an indication of failure. + return not_found; + } // end find_next + + + template + unsigned char bit_count::value[] = { + 0, /* 0 */ 1, /* 1 */ 1, /* 2 */ 2, /* 3 */ 1, /* 4 */ + 2, /* 5 */ 2, /* 6 */ 3, /* 7 */ 1, /* 8 */ 2, /* 9 */ + 2, /* 10 */ 3, /* 11 */ 2, /* 12 */ 3, /* 13 */ 3, /* 14 */ + 4, /* 15 */ 1, /* 16 */ 2, /* 17 */ 2, /* 18 */ 3, /* 19 */ + 2, /* 20 */ 3, /* 21 */ 3, /* 22 */ 4, /* 23 */ 2, /* 24 */ + 3, /* 25 */ 3, /* 26 */ 4, /* 27 */ 3, /* 28 */ 4, /* 29 */ + 4, /* 30 */ 5, /* 31 */ 1, /* 32 */ 2, /* 33 */ 2, /* 34 */ + 3, /* 35 */ 2, /* 36 */ 3, /* 37 */ 3, /* 38 */ 4, /* 39 */ + 2, /* 40 */ 3, /* 41 */ 3, /* 42 */ 4, /* 43 */ 3, /* 44 */ + 4, /* 45 */ 4, /* 46 */ 5, /* 47 */ 2, /* 48 */ 3, /* 49 */ + 3, /* 50 */ 4, /* 51 */ 3, /* 52 */ 4, /* 53 */ 4, /* 54 */ + 5, /* 55 */ 3, /* 56 */ 4, /* 57 */ 4, /* 58 */ 5, /* 59 */ + 4, /* 60 */ 5, /* 61 */ 5, /* 62 */ 6, /* 63 */ 1, /* 64 */ + 2, /* 65 */ 2, /* 66 */ 3, /* 67 */ 2, /* 68 */ 3, /* 69 */ + 3, /* 70 */ 4, /* 71 */ 2, /* 72 */ 3, /* 73 */ 3, /* 74 */ + 4, /* 75 */ 3, /* 76 */ 4, /* 77 */ 4, /* 78 */ 5, /* 79 */ + 2, /* 80 */ 3, /* 81 */ 3, /* 82 */ 4, /* 83 */ 3, /* 84 */ + 4, /* 85 */ 4, /* 86 */ 5, /* 87 */ 3, /* 88 */ 4, /* 89 */ + 4, /* 90 */ 5, /* 91 */ 4, /* 92 */ 5, /* 93 */ 5, /* 94 */ + 6, /* 95 */ 2, /* 96 */ 3, /* 97 */ 3, /* 98 */ 4, /* 99 */ + 3, /* 100 */ 4, /* 101 */ 4, /* 102 */ 5, /* 103 */ 3, /* 104 */ + 4, /* 105 */ 4, /* 106 */ 5, /* 107 */ 4, /* 108 */ 5, /* 109 */ + 5, /* 110 */ 6, /* 111 */ 3, /* 112 */ 4, /* 113 */ 4, /* 114 */ + 5, /* 115 */ 4, /* 116 */ 5, /* 117 */ 5, /* 118 */ 6, /* 119 */ + 4, /* 120 */ 5, /* 121 */ 5, /* 122 */ 6, /* 123 */ 5, /* 124 */ + 6, /* 125 */ 6, /* 126 */ 7, /* 127 */ 1, /* 128 */ 2, /* 129 */ + 2, /* 130 */ 3, /* 131 */ 2, /* 132 */ 3, /* 133 */ 3, /* 134 */ + 4, /* 135 */ 2, /* 136 */ 3, /* 137 */ 3, /* 138 */ 4, /* 139 */ + 3, /* 140 */ 4, /* 141 */ 4, /* 142 */ 5, /* 143 */ 2, /* 144 */ + 3, /* 145 */ 3, /* 146 */ 4, /* 147 */ 3, /* 148 */ 4, /* 149 */ + 4, /* 150 */ 5, /* 151 */ 3, /* 152 */ 4, /* 153 */ 4, /* 154 */ + 5, /* 155 */ 4, /* 156 */ 5, /* 157 */ 5, /* 158 */ 6, /* 159 */ + 2, /* 160 */ 3, /* 161 */ 3, /* 162 */ 4, /* 163 */ 3, /* 164 */ + 4, /* 165 */ 4, /* 166 */ 5, /* 167 */ 3, /* 168 */ 4, /* 169 */ + 4, /* 170 */ 5, /* 171 */ 4, /* 172 */ 5, /* 173 */ 5, /* 174 */ + 6, /* 175 */ 3, /* 176 */ 4, /* 177 */ 4, /* 178 */ 5, /* 179 */ + 4, /* 180 */ 5, /* 181 */ 5, /* 182 */ 6, /* 183 */ 4, /* 184 */ + 5, /* 185 */ 5, /* 186 */ 6, /* 187 */ 5, /* 188 */ 6, /* 189 */ + 6, /* 190 */ 7, /* 191 */ 2, /* 192 */ 3, /* 193 */ 3, /* 194 */ + 4, /* 195 */ 3, /* 196 */ 4, /* 197 */ 4, /* 198 */ 5, /* 199 */ + 3, /* 200 */ 4, /* 201 */ 4, /* 202 */ 5, /* 203 */ 4, /* 204 */ + 5, /* 205 */ 5, /* 206 */ 6, /* 207 */ 3, /* 208 */ 4, /* 209 */ + 4, /* 210 */ 5, /* 211 */ 4, /* 212 */ 5, /* 213 */ 5, /* 214 */ + 6, /* 215 */ 4, /* 216 */ 5, /* 217 */ 5, /* 218 */ 6, /* 219 */ + 5, /* 220 */ 6, /* 221 */ 6, /* 222 */ 7, /* 223 */ 3, /* 224 */ + 4, /* 225 */ 4, /* 226 */ 5, /* 227 */ 4, /* 228 */ 5, /* 229 */ + 5, /* 230 */ 6, /* 231 */ 4, /* 232 */ 5, /* 233 */ 5, /* 234 */ + 6, /* 235 */ 5, /* 236 */ 6, /* 237 */ 6, /* 238 */ 7, /* 239 */ + 4, /* 240 */ 5, /* 241 */ 5, /* 242 */ 6, /* 243 */ 5, /* 244 */ + 6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */ + 6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */ + 8 /* 255 */ + }; // end _Bit_count + + template + unsigned char first_bit_location::value[] = { + 0, /* 0 */ 0, /* 1 */ 1, /* 2 */ 0, /* 3 */ 2, /* 4 */ + 0, /* 5 */ 1, /* 6 */ 0, /* 7 */ 3, /* 8 */ 0, /* 9 */ + 1, /* 10 */ 0, /* 11 */ 2, /* 12 */ 0, /* 13 */ 1, /* 14 */ + 0, /* 15 */ 4, /* 16 */ 0, /* 17 */ 1, /* 18 */ 0, /* 19 */ + 2, /* 20 */ 0, /* 21 */ 1, /* 22 */ 0, /* 23 */ 3, /* 24 */ + 0, /* 25 */ 1, /* 26 */ 0, /* 27 */ 2, /* 28 */ 0, /* 29 */ + 1, /* 30 */ 0, /* 31 */ 5, /* 32 */ 0, /* 33 */ 1, /* 34 */ + 0, /* 35 */ 2, /* 36 */ 0, /* 37 */ 1, /* 38 */ 0, /* 39 */ + 3, /* 40 */ 0, /* 41 */ 1, /* 42 */ 0, /* 43 */ 2, /* 44 */ + 0, /* 45 */ 1, /* 46 */ 0, /* 47 */ 4, /* 48 */ 0, /* 49 */ + 1, /* 50 */ 0, /* 51 */ 2, /* 52 */ 0, /* 53 */ 1, /* 54 */ + 0, /* 55 */ 3, /* 56 */ 0, /* 57 */ 1, /* 58 */ 0, /* 59 */ + 2, /* 60 */ 0, /* 61 */ 1, /* 62 */ 0, /* 63 */ 6, /* 64 */ + 0, /* 65 */ 1, /* 66 */ 0, /* 67 */ 2, /* 68 */ 0, /* 69 */ + 1, /* 70 */ 0, /* 71 */ 3, /* 72 */ 0, /* 73 */ 1, /* 74 */ + 0, /* 75 */ 2, /* 76 */ 0, /* 77 */ 1, /* 78 */ 0, /* 79 */ + 4, /* 80 */ 0, /* 81 */ 1, /* 82 */ 0, /* 83 */ 2, /* 84 */ + 0, /* 85 */ 1, /* 86 */ 0, /* 87 */ 3, /* 88 */ 0, /* 89 */ + 1, /* 90 */ 0, /* 91 */ 2, /* 92 */ 0, /* 93 */ 1, /* 94 */ + 0, /* 95 */ 5, /* 96 */ 0, /* 97 */ 1, /* 98 */ 0, /* 99 */ + 2, /* 100 */ 0, /* 101 */ 1, /* 102 */ 0, /* 103 */ 3, /* 104 */ + 0, /* 105 */ 1, /* 106 */ 0, /* 107 */ 2, /* 108 */ 0, /* 109 */ + 1, /* 110 */ 0, /* 111 */ 4, /* 112 */ 0, /* 113 */ 1, /* 114 */ + 0, /* 115 */ 2, /* 116 */ 0, /* 117 */ 1, /* 118 */ 0, /* 119 */ + 3, /* 120 */ 0, /* 121 */ 1, /* 122 */ 0, /* 123 */ 2, /* 124 */ + 0, /* 125 */ 1, /* 126 */ 0, /* 127 */ 7, /* 128 */ 0, /* 129 */ + 1, /* 130 */ 0, /* 131 */ 2, /* 132 */ 0, /* 133 */ 1, /* 134 */ + 0, /* 135 */ 3, /* 136 */ 0, /* 137 */ 1, /* 138 */ 0, /* 139 */ + 2, /* 140 */ 0, /* 141 */ 1, /* 142 */ 0, /* 143 */ 4, /* 144 */ + 0, /* 145 */ 1, /* 146 */ 0, /* 147 */ 2, /* 148 */ 0, /* 149 */ + 1, /* 150 */ 0, /* 151 */ 3, /* 152 */ 0, /* 153 */ 1, /* 154 */ + 0, /* 155 */ 2, /* 156 */ 0, /* 157 */ 1, /* 158 */ 0, /* 159 */ + 5, /* 160 */ 0, /* 161 */ 1, /* 162 */ 0, /* 163 */ 2, /* 164 */ + 0, /* 165 */ 1, /* 166 */ 0, /* 167 */ 3, /* 168 */ 0, /* 169 */ + 1, /* 170 */ 0, /* 171 */ 2, /* 172 */ 0, /* 173 */ 1, /* 174 */ + 0, /* 175 */ 4, /* 176 */ 0, /* 177 */ 1, /* 178 */ 0, /* 179 */ + 2, /* 180 */ 0, /* 181 */ 1, /* 182 */ 0, /* 183 */ 3, /* 184 */ + 0, /* 185 */ 1, /* 186 */ 0, /* 187 */ 2, /* 188 */ 0, /* 189 */ + 1, /* 190 */ 0, /* 191 */ 6, /* 192 */ 0, /* 193 */ 1, /* 194 */ + 0, /* 195 */ 2, /* 196 */ 0, /* 197 */ 1, /* 198 */ 0, /* 199 */ + 3, /* 200 */ 0, /* 201 */ 1, /* 202 */ 0, /* 203 */ 2, /* 204 */ + 0, /* 205 */ 1, /* 206 */ 0, /* 207 */ 4, /* 208 */ 0, /* 209 */ + 1, /* 210 */ 0, /* 211 */ 2, /* 212 */ 0, /* 213 */ 1, /* 214 */ + 0, /* 215 */ 3, /* 216 */ 0, /* 217 */ 1, /* 218 */ 0, /* 219 */ + 2, /* 220 */ 0, /* 221 */ 1, /* 222 */ 0, /* 223 */ 5, /* 224 */ + 0, /* 225 */ 1, /* 226 */ 0, /* 227 */ 2, /* 228 */ 0, /* 229 */ + 1, /* 230 */ 0, /* 231 */ 3, /* 232 */ 0, /* 233 */ 1, /* 234 */ + 0, /* 235 */ 2, /* 236 */ 0, /* 237 */ 1, /* 238 */ 0, /* 239 */ + 4, /* 240 */ 0, /* 241 */ 1, /* 242 */ 0, /* 243 */ 2, /* 244 */ + 0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */ + 1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */ + 0, /* 255 */ + }; // end _First_one + + } // namespace detail + +} // namespace boost diff --git a/deal.II/contrib/boost/include/boost/graph/detail/bitset_adaptor.hpp b/deal.II/contrib/boost/include/boost/graph/detail/bitset_adaptor.hpp new file mode 100644 index 0000000000..d301b7d623 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/bitset_adaptor.hpp @@ -0,0 +1,90 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_BITSET_ADAPTOR_HPP +#define BOOST_BITSET_ADAPTOR_HPP + + template + struct bitset_adaptor { + Derived& derived() { return static_cast(*this); } + const Derived& derived() const { + return static_cast(*this); + } + }; + + template + bool set_contains(const bitset_adaptor& s, const V& x) { + return s.derived().test(x); + } + + template + bool set_equal(const bitset_adaptor& x, + const bitset_adaptor& y) { + return x.derived() == y.derived(); + } + + template + int set_lex_order(const bitset_adaptor& x, + const bitset_adaptor& y) { + return compare_3way(x.derived(), y.derived()); + } + + template + void set_clear(bitset_adaptor& x) { + x.derived().reset(); + } + + template + bool set_empty(const bitset_adaptor& x) { + return x.derived().none(); + } + + template + void set_insert(bitset_adaptor& x, const V& a) { + x.derived().set(a); + } + + template + void set_remove(bitset_adaptor& x, const V& a) { + x.derived().set(a, false); + } + + template + void set_intersect(const bitset_adaptor& x, + const bitset_adaptor& y, + bitset_adaptor& z) + { + z.derived() = x.derived() & y.derived(); + } + + template + void set_union(const bitset_adaptor& x, + const bitset_adaptor& y, + bitset_adaptor& z) + { + z.derived() = x.derived() | y.derived(); + } + + template + void set_difference(const bitset_adaptor& x, + const bitset_adaptor& y, + bitset_adaptor& z) + { + z.derived() = x.derived() - y.derived(); + } + + template + void set_compliment(const bitset_adaptor& x, + bitset_adaptor& z) + { + z.derived() = x.derived(); + z.derived().flip(); + } + +#endif // BOOST_BITSET_ADAPTOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/connected_components.hpp b/deal.II/contrib/boost/include/boost/graph/detail/connected_components.hpp new file mode 100644 index 0000000000..0af7746012 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/connected_components.hpp @@ -0,0 +1,208 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_CONNECTED_COMPONENTS_HPP +#define BOOST_GRAPH_DETAIL_CONNECTED_COMPONENTS_HPP + +#if defined(__sgi) && !defined(__GNUC__) +#pragma set woff 1234 +#endif + +#include + +namespace boost { + + namespace detail { + + //========================================================================= + // Implementation details of connected_components + + // This is used both in the connected_components algorithm and in + // the kosaraju strong components algorithm during the second DFS + // traversal. + template + class components_recorder : public DFSVisitor + { + typedef typename property_traits::value_type comp_type; + public: + components_recorder(ComponentsPA c, + comp_type& c_count, + DFSVisitor v) + : DFSVisitor(v), m_component(c), m_count(c_count) {} + + template + void start_vertex(Vertex u, Graph& g) { + ++m_count; + DFSVisitor::start_vertex(u, g); + } + template + void discover_vertex(Vertex u, Graph& g) { + put(m_component, u, m_count); + DFSVisitor::discover_vertex(u, g); + } + protected: + ComponentsPA m_component; + comp_type& m_count; + }; + + template + class time_recorder : public DFSVisitor + { + public: + time_recorder(DiscoverTimeMap d, FinishTimeMap f, TimeT& t, DFSVisitor v) + : DFSVisitor(v), m_discover_time(d), m_finish_time(f), m_t(t) {} + + template + void discover_vertex(Vertex u, Graph& g) { + put(m_discover_time, u, ++m_t); + DFSVisitor::discover_vertex(u, g); + } + template + void finish_vertex(Vertex u, Graph& g) { + put(m_finish_time, u, ++m_t); + DFSVisitor::discover_vertex(u, g); + } + protected: + DiscoverTimeMap m_discover_time; + FinishTimeMap m_finish_time; + TimeT m_t; + }; + template + time_recorder + record_times(DiscoverTimeMap d, FinishTimeMap f, TimeT& t, DFSVisitor vis) + { + return time_recorder + (d, f, t, vis); + } + + //========================================================================= + // Implementation detail of dynamic_components + + + //------------------------------------------------------------------------- + // Helper functions for the component_index class + + // Record the representative vertices in the header array. + // Representative vertices now point to the component number. + + template + inline void + build_components_header(Parent p, + OutputIterator header, + Integer num_nodes) + { + Parent component = p; + Integer component_num = 0; + for (Integer v = 0; v != num_nodes; ++v) + if (p[v] == v) { + *header++ = v; + component[v] = component_num++; + } + } + + + // Pushes x onto the front of the list. The list is represented in + // an array. + template + inline void push_front(Next next, T& head, V x) + { + T tmp = head; + head = x; + next[x] = tmp; + } + + + // Create a linked list of the vertices in each component + // by reusing the representative array. + template + void + link_components(Parent1 component, Parent2 header, + Integer num_nodes, Integer num_components) + { + // Make the non-representative vertices point to their component + Parent1 representative = component; + for (Integer v = 0; v != num_nodes; ++v) + if (component[v] >= num_components || header[component[v]] != v) + component[v] = component[representative[v]]; + + // initialize the "head" of the lists to "NULL" + std::fill_n(header, num_components, num_nodes); + + // Add each vertex to the linked list for its component + Parent1 next = component; + for (Integer k = 0; k != num_nodes; ++k) + push_front(next, header[component[k]], k); + } + + + + template + void + construct_component_index(IndexContainer& index, HeaderContainer& header) + { + build_components_header(index.begin(), + std::back_inserter(header), + index.end() - index.begin()); + + link_components(index.begin(), header.begin(), + index.end() - index.begin(), + header.end() - header.begin()); + } + + + + template + class component_iterator + : boost::forward_iterator_helper< + component_iterator, + Integer, Distance,Integer*, Integer&> + { + public: + typedef component_iterator self; + + IndexIterator next; + Integer node; + + typedef std::forward_iterator_tag iterator_category; + typedef Integer value_type; + typedef Integer& reference; + typedef Integer* pointer; + typedef Distance difference_type; + + component_iterator() {} + component_iterator(IndexIterator x, Integer i) + : next(x), node(i) {} + Integer operator*() const { + return node; + } + self& operator++() { + node = next[node]; + return *this; + } + }; + + template + inline bool + operator==(const component_iterator& x, + const component_iterator& y) + { + return x.node == y.node; + } + + } // namespace detail + +} // namespace detail + +#if defined(__sgi) && !defined(__GNUC__) +#pragma reset woff 1234 +#endif + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/detail/edge.hpp b/deal.II/contrib/boost/include/boost/graph/detail/edge.hpp new file mode 100644 index 0000000000..8ab375f064 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/edge.hpp @@ -0,0 +1,94 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_EDGE_HPP +#define BOOST_GRAPH_DETAIL_EDGE_HPP + +#if __GNUC__ < 3 +#include +#else +#include +#endif + +namespace boost { + + namespace detail { + + template + struct edge_base + { + inline edge_base() {} + inline edge_base(Vertex s, Vertex d) + : m_source(s), m_target(d) { } + Vertex m_source; + Vertex m_target; + }; + + template + class edge_desc_impl : public edge_base { + typedef edge_desc_impl self; + typedef edge_base Base; + public: + typedef void property_type; + + inline edge_desc_impl() : m_eproperty(0) {} + + inline edge_desc_impl(Vertex s, Vertex d, const property_type* eplug) + : Base(s,d), m_eproperty(const_cast(eplug)) { } + + property_type* get_property() { return m_eproperty; } + const property_type* get_property() const { return m_eproperty; } + + // protected: + property_type* m_eproperty; + }; + + template + inline bool + operator==(const detail::edge_desc_impl& a, + const detail::edge_desc_impl& b) + { + return a.get_property() == b.get_property(); + } + template + inline bool + operator!=(const detail::edge_desc_impl& a, + const detail::edge_desc_impl& b) + { + return ! (a.get_property() == b.get_property()); + } + + } //namespace detail + +} // namespace boost + +namespace std { + +#if __GNUC__ < 3 + template + std::ostream& + operator<<(std::ostream& os, const boost::detail::edge_desc_impl& e) + { + return os << "(" << e.m_source << "," << e.m_target << ")"; + } +#else + template + std::basic_ostream& + operator<<(std::basic_ostream& os, + const boost::detail::edge_desc_impl& e) + { + return os << "(" << e.m_source << "," << e.m_target << ")"; + } +#endif + +} + + +#endif // BOOST_GRAPH_DETAIL_DETAIL_EDGE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/incidence_iterator.hpp b/deal.II/contrib/boost/include/boost/graph/detail/incidence_iterator.hpp new file mode 100644 index 0000000000..836ad15266 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/incidence_iterator.hpp @@ -0,0 +1,79 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_INCIDENCE_ITERATOR_HPP +#define BOOST_GRAPH_DETAIL_INCIDENCE_ITERATOR_HPP + +#include +#include + +// OBSOLETE + +namespace boost { + + namespace detail { + // EdgeDir tags + struct in_edge_tag { }; + struct out_edge_tag { }; + + template + struct bidir_incidence_iterator { + typedef bidir_incidence_iterator self; + typedef Edge edge_type; + typedef typename Edge::property_type EdgeProperty; + public: + typedef int difference_type; + typedef std::forward_iterator_tag iterator_category; + typedef edge_type reference; + typedef edge_type value_type; + typedef value_type* pointer; + inline bidir_incidence_iterator() {} + inline bidir_incidence_iterator(Iterator1D ii, Vertex src) + : i(ii), _src(src) { } + + inline self& operator++() { ++i; return *this; } + inline self operator++(int) { self tmp = *this; ++(*this); return tmp; } + + inline reference operator*() const { + return deref_helper(EdgeDir()); + } + inline self* operator->() { return this; } + + Iterator1D& iter() { return i; } + const Iterator1D& iter() const { return i; } + + Iterator1D i; + Vertex _src; + protected: + inline reference deref_helper(out_edge_tag) const { + return edge_type( _src, (*i).get_target(), &(*i).get_property() ); + } + inline reference deref_helper(in_edge_tag) const { + return edge_type((*i).get_target(), _src, &(*i).get_property() ); + } + }; + + template + inline bool operator==(const bidir_incidence_iterator& x, + const bidir_incidence_iterator& y) + { + return x.i == y.i; + } + template + inline bool operator!=(const bidir_incidence_iterator& x, + const bidir_incidence_iterator& y) + { + return x.i != y.i; + } + + + } +} +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/detail/incremental_components.hpp b/deal.II/contrib/boost/include/boost/graph/detail/incremental_components.hpp new file mode 100644 index 0000000000..cf08bea091 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/incremental_components.hpp @@ -0,0 +1,141 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_INCREMENTAL_COMPONENTS_HPP +#define BOOST_GRAPH_DETAIL_INCREMENTAL_COMPONENTS_HPP + +#include +#include + +namespace boost { + + namespace detail { + + //========================================================================= + // Implementation detail of incremental_components + + + //------------------------------------------------------------------------- + // Helper functions for the component_index class + + // Record the representative vertices in the header array. + // Representative vertices now point to the component number. + + template + inline void + build_components_header(Parent p, + OutputIterator header, + Integer num_nodes) + { + Parent component = p; + Integer component_num = 0; + for (Integer v = 0; v != num_nodes; ++v) + if (p[v] == v) { + *header++ = v; + component[v] = component_num++; + } + } + + + // Pushes x onto the front of the list. The list is represented in + // an array. + template + inline void array_push_front(Next next, T& head, V x) + { + T tmp = head; + head = x; + next[x] = tmp; + } + + + // Create a linked list of the vertices in each component + // by reusing the representative array. + template + void + link_components(Parent1 component, Parent2 header, + Integer num_nodes, Integer num_components) + { + // Make the non-representative vertices point to their component + Parent1 representative = component; + for (Integer v = 0; v != num_nodes; ++v) + if (component[v] >= num_components + || header[component[v]] != v) + component[v] = component[representative[v]]; + + // initialize the "head" of the lists to "NULL" + std::fill_n(header, num_components, num_nodes); + + // Add each vertex to the linked list for its component + Parent1 next = component; + for (Integer k = 0; k != num_nodes; ++k) + array_push_front(next, header[component[k]], k); + } + + + + template + void + construct_component_index(IndexContainer& index, HeaderContainer& header) + { + typedef typename IndexContainer::value_type Integer; + build_components_header(index.begin(), + std::back_inserter(header), + Integer(index.end() - index.begin())); + + link_components(index.begin(), header.begin(), + Integer(index.end() - index.begin()), + Integer(header.end() - header.begin())); + } + + + + template + class component_iterator + : boost::forward_iterator_helper< + component_iterator, + Integer, Distance,Integer*, Integer&> + { + public: + typedef component_iterator self; + + IndexIterator next; + Integer node; + + typedef std::forward_iterator_tag iterator_category; + typedef Integer value_type; + typedef Integer& reference; + typedef Integer* pointer; + typedef Distance difference_type; + + component_iterator() {} + component_iterator(IndexIterator x, Integer i) + : next(x), node(i) {} + Integer operator*() const { + return node; + } + self& operator++() { + node = next[node]; + return *this; + } + }; + + template + inline bool + operator==(const component_iterator& x, + const component_iterator& y) + { + return x.node == y.node; + } + + } // namespace detail + +} // namespace detail + +#endif // BOOST_GRAPH_DETAIL_INCREMENTAL_COMPONENTS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/is_same.hpp b/deal.II/contrib/boost/include/boost/graph/detail/is_same.hpp new file mode 100644 index 0000000000..cda8d56114 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/is_same.hpp @@ -0,0 +1,40 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_IS_SAME_HPP +#define BOOST_GRAPH_DETAIL_IS_SAME_HPP + +#include + +namespace boost { + struct false_tag; + struct true_tag; + + namespace graph_detail { + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct is_same { + typedef boost::false_tag is_same_tag; + }; + template + struct is_same { + typedef boost::true_tag is_same_tag; + }; +#else + template + struct is_same { + enum { Unum = U::num, Vnum = V::num }; + typedef typename boost::ct_if< (Unum == Vnum), + boost::true_tag, boost::false_tag>::type is_same_tag; + }; +#endif + } // namespace graph_detail +} // namespace boost + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/detail/list_base.hpp b/deal.II/contrib/boost/include/boost/graph/detail/list_base.hpp new file mode 100644 index 0000000000..88d831650b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/list_base.hpp @@ -0,0 +1,220 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_LIST_BASE_HPP +#define BOOST_LIST_BASE_HPP + +#include + +// Perhaps this should go through formal review, and move to . + +/* + An alternate interface idea: + Extend the std::list functionality by creating remove/insert + functions that do not require the container object! + */ + +namespace boost { + namespace detail { + + //========================================================================= + // Linked-List Generic Implementation Functions + + template + inline Node + slist_insert_after(Node pos, Node x, + Next next) + { + next(x) = next(pos); + next(pos) = x; + return x; + } + + // return next(pos) or next(next(pos)) ? + template + inline Node + slist_remove_after(Node pos, + Next next) + { + Node n = next(pos); + next(pos) = next(n); + return n; + } + + template + inline Node + slist_remove_range(Node before_first, Node last, + Next next) + { + next(before_first) = last; + return last; + } + + template + inline Node + slist_previous(Node head, Node x, Node nil, + Next next) + { + while (head != nil && next(head) != x) + head = next(head); + return head; + } + + template + inline void + slist_splice_after(Node pos, Node before_first, Node before_last, + Next next) + { + if (pos != before_first && pos != before_last) { + Node first = next(before_first); + Node after = next(pos); + next(before_first) = next(before_last); + next(pos) = first; + next(before_last) = after; + } + } + + template + inline Node + slist_reverse(Node node, Node nil, + Next next) + { + Node result = node; + node = next(node); + next(result) = nil; + while(node) { + Node next = next(node); + next(node) = result; + result = node; + node = next; + } + return result; + } + + template + inline std::size_t + slist_size(Node head, Node nil, + Next next) + { + std::size_t s = 0; + for ( ; head != nil; head = next(head)) + ++s; + return s; + } + + template + class slist_iterator_policies + { + public: + explicit slist_iterator_policies(const Next& n, const Data& d) + : m_next(n), m_data(d) { } + + template + Reference dereference(type, const Node& x) const + { return m_data(x); } + + template + void increment(Node& x) const + { x = m_next(x); } + + template + bool equal(Node& x, Node& y) const + { return x == y; } + + protected: + Next m_next; + Data m_data; + }; + + //=========================================================================== + // Doubly-Linked List Generic Implementation Functions + + template + inline void + dlist_insert_before(Node pos, Node x, + Next next, Prev prev) + { + next(x) = pos; + prev(x) = prev(pos); + next(prev(pos)) = x; + prev(pos) = x; + } + + template + void + dlist_remove(Node pos, + Next next, Prev prev) + { + Node next_node = next(pos); + Node prev_node = prev(pos); + next(prev_node) = next_node; + prev(next_node) = prev_node; + } + + // This deletes every node in the list except the + // sentinel node. + template + inline void + dlist_clear(Node sentinel, Delete del) + { + Node i, tmp; + i = next(sentinel); + while (i != sentinel) { + tmp = i; + i = next(i); + del(tmp); + } + } + + template + inline bool + dlist_empty(Node dummy) + { + return next(dummy) == dummy; + } + + template + void + dlist_transfer(Node pos, Node first, Node last, + Next next, Prev prev) + { + if (pos != last) { + // Remove [first,last) from its old position + next(prev(last)) = pos; + next(prev(first)) = last; + next(prev(pos)) = first; + + // Splice [first,last) into its new position + Node tmp = prev(pos); + prev(pos) = prev(last); + prev(last) = prev(first); + prev(first) = tmp; + } + } + + template + class dlist_iterator_policies + : public slist_iterator_policies + { + typedef slist_iterator_policies Base; + public: + template + void decrement(Node& x) const + { x = m_prev(x); } + + dlist_iterator_policies(Next n, Prev p, Data d) + : Base(n,d), m_prev(p) { } + protected: + Prev m_prev; + }; + + } // namespace detail +} // namespace boost + +#endif // BOOST_LIST_BASE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/permutation.hpp b/deal.II/contrib/boost/include/boost/graph/detail/permutation.hpp new file mode 100644 index 0000000000..f1db906ab1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/permutation.hpp @@ -0,0 +1,205 @@ +// (C) Copyright Jeremy Siek 2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PERMUTATION_HPP +#define BOOST_PERMUTATION_HPP + +#include +#include +#include +#include +#include + +namespace boost { + +template +void permute_serial(Iter1 permuter, Iter1 last, Iter2 result) +{ +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + typedef std::ptrdiff_t D: +#else + typedef typename std::iterator_traits::difference_type D; +#endif + + D n = 0; + while (permuter != last) { + std::swap(result[n], result[*permuter]); + ++n; + ++permuter; + } +} + +template +void permute_copy(InIter first, InIter last, RandIterP p, RandIterR result) +{ +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + typedef std::ptrdiff_t i = 0; +#else + typename std::iterator_traits::difference_type i = 0; +#endif + for (; first != last; ++first, ++i) + result[p[i]] = *first; +} + +namespace detail { + +template +void permute_helper(RandIter first, RandIter last, RandIterPerm p, D, T) +{ + D i = 0, pi, n = last - first, cycle_start; + T tmp; + std::vector visited(n, false); + + while (i != n) { // continue until all elements have been processed + cycle_start = i; + tmp = first[i]; + do { // walk around a cycle + pi = p[i]; + visited[pi] = true; + std::swap(tmp, first[pi]); + i = pi; + } while (i != cycle_start); + + // find the next cycle + for (i = 0; i < n; ++i) + if (visited[i] == false) + break; + } +} + +} // namespace detail + +template +void permute(RandIter first, RandIter last, RandIterPerm p) +{ + detail::permute_helper(first, last, p, last - first, *first); +} + + +// Knuth 1.3.3, Vol. 1 p 176 +// modified for zero-based arrays +// time complexity? +// +// WARNING: T must be a signed integer! +template +void invert_permutation(PermIter X, PermIter Xend) +{ +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + typedef std::ptrdiff_t T: +#else + typedef typename std::iterator_traits::value_type T; +#endif + T n = Xend - X; + T m = n; + T j = -1; + + while (m > 0) { + T i = X[m-1] + 1; + if (i > 0) { + do { + X[m-1] = j - 1; + j = -m; + m = i; + i = X[m-1] + 1; + } while (i > 0); + i = j; + } + X[m-1] = -i - 1; + --m; + } +} + +// Takes a "normal" permutation array (and its inverse), and turns it +// into a BLAS-style permutation array (which can be thought of as a +// serialized permutation). +template +inline void serialize_permutation(Iter1 q, Iter1 q_end, Iter2 q_inv, Iter3 p) +{ +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + typedef std::ptrdiff_t P1; + typedef std::ptrdiff_t P2; + typedef std::ptrdiff_t D; +#else + typedef typename std::iterator_traits::value_type P1; + typedef typename std::iterator_traits::value_type P2; + typedef typename std::iterator_traits::difference_type D; +#endif + D n = q_end - q; + for (D i = 0; i < n; ++i) { + P1 qi = q[i]; + P2 qii = q_inv[i]; + *p++ = qii; + std::swap(q[i], q[qii]); + std::swap(q_inv[i], q_inv[qi]); + } +} + +// Not used anymore, leaving it here for future reference. +template +void merge_sort(Iter first, Iter last, Compare cmp) +{ + if (first + 1 < last) { + Iter mid = first + (last - first)/2; + merge_sort(first, mid, cmp); + merge_sort(mid, last, cmp); + std::inplace_merge(first, mid, last, cmp); + } +} + + +// time: N log N + 3N + ? +// space: 2N +template +inline void sortp(Iter first, Iter last, IterP p, Cmp cmp, Alloc alloc) +{ + typedef typename std::iterator_traits::value_type P; + typedef typename std::iterator_traits::difference_type D; + D n = last - first; + std::vector q(n); + for (D i = 0; i < n; ++i) + q[i] = i; + std::sort(make_shadow_iter(first, q.begin()), + make_shadow_iter(last, q.end()), + shadow_cmp(cmp)); + invert_permutation(q.begin(), q.end()); + std::copy(q.begin(), q.end(), p); +} + +template +inline void sortp(Iter first, Iter last, IterP p, Cmp cmp) +{ + typedef typename std::iterator_traits::value_type P; + sortp(first, last, p, cmp, std::allocator

()); +} + +template +inline void sortp(Iter first, Iter last, IterP p) +{ + typedef typename std::iterator_traits::value_type T; + typedef typename std::iterator_traits::value_type P; + sortp(first, last, p, std::less(), std::allocator

()); +} + +template +inline void sortv(Iter first, Iter last, IterP p, Cmp cmp, Alloc alloc) +{ + typedef typename std::iterator_traits::value_type P; + typedef typename std::iterator_traits::difference_type D; + D n = last - first; + std::vector q(n), q_inv(n); + for (D i = 0; i < n; ++i) + q_inv[i] = i; + std::sort(make_shadow_iter(first, q_inv.begin()), + make_shadow_iter(last, q_inv.end()), + shadow_cmp(cmp)); + std::copy(q_inv, q_inv.end(), q.begin()); + invert_permutation(q.begin(), q.end()); + serialize_permutation(q.begin(), q.end(), q_inv.end(), p); +} + + +} // namespace boost + +#endif // BOOST_PERMUTATION_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/read_graphviz_spirit.hpp b/deal.II/contrib/boost/include/boost/graph/detail/read_graphviz_spirit.hpp new file mode 100644 index 0000000000..07b298d2c1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/read_graphviz_spirit.hpp @@ -0,0 +1,584 @@ +// Copyright 2004-5 Trustees of Indiana University + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// +// read_graphviz_spirit.hpp - +// Initialize a model of the BGL's MutableGraph concept and an associated +// collection of property maps using a graph expressed in the GraphViz +// DOT Language. +// +// Based on the grammar found at: +// http://www.graphviz.org/cvs/doc/info/lang.html +// +// See documentation for this code at: +// http://www.boost.org/libs/graph/doc/read-graphviz.html +// + +// Author: Ronald Garcia +// + +#ifndef BOOST_READ_GRAPHVIZ_SPIRIT_HPP +#define BOOST_READ_GRAPHVIZ_SPIRIT_HPP + +// Phoenix/Spirit set these limits to 3, but I need more. +#define PHOENIX_LIMIT 6 +#define BOOST_SPIRIT_CLOSURE_LIMIT 6 + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for std::exception +#include +#include +#include +#include +#include +#include + +namespace phoenix { +// Workaround: std::map::operator[] uses a different return type than all +// other standard containers. Phoenix doesn't account for that. +template +struct binary_operator, T1> +{ + typedef typename std::map::mapped_type& result_type; + static result_type eval(std::map& container, T1 const& index) + { return container[index]; } +}; +} // namespace phoenix + +namespace boost { +namespace detail { +namespace graph { + +using namespace std; +using namespace boost; +using namespace boost::spirit; +using namespace phoenix; + +///////////////////////////////////////////////////////////////////////////// +// Application-specific type definitions +///////////////////////////////////////////////////////////////////////////// + +typedef std::set edges_t; +typedef std::set nodes_t; +typedef std::set ids_t; +typedef std::map edge_map_t; +typedef std::map node_map_t; +typedef std::map props_t; +typedef std::map subgraph_props_t; +typedef boost::function2 actor_t; +typedef std::vector edge_stack_t; +typedef std::map subgraph_nodes_t; +typedef std::map subgraph_edges_t; + + + +///////////////////////////////////////////////////////////////////////////// +// Stack frames used by semantic actions +///////////////////////////////////////////////////////////////////////////// +struct id_closure : boost::spirit::closure { + member1 name; +}; + + +struct node_id_closure : boost::spirit::closure { + member1 name; +}; + +struct attr_list_closure : boost::spirit::closure { + member1 prop_actor; +}; + +struct property_closure : boost::spirit::closure { + member1 key; + member2 value; +}; + +struct data_stmt_closure : boost::spirit::closure { + member1 sources; + member2 dests; + member3 edge_stack; + member4 saw_node; + member5 active_node; +}; + +struct subgraph_closure : boost::spirit::closure { + member1 nodes; + member2 edges; + member3 name; +}; + +///////////////////////////////////////////////////////////////////////////// +// Grammar and Actions for the DOT Language +///////////////////////////////////////////////////////////////////////////// + +// Grammar for a dot file. +struct dot_grammar : public grammar { + mutate_graph& graph_; + explicit dot_grammar(mutate_graph& graph) : graph_(graph) { } + + template + struct definition { + + definition(dot_grammar const& self) : self(self), subgraph_depth(0), + keyword_p("0-9a-zA-Z_") { + + + // RG - Future Work + // - Handle multi-line strings using \ line continuation + // - Make keywords case insensitive + + ID + = ( lexeme_d[((alpha_p | ch_p('_')) >> *(alnum_p | ch_p('_')))] + | real_p + | confix_p('"', *c_escape_ch_p, '"') + | comment_nest_p('<', '>') + )[ID.name = construct_(arg1,arg2)] + ; + + a_list + = list_p( ID[(a_list.key = arg1), + (a_list.value = "true") + ] + >> !( ch_p('=') + >> ID[a_list.value = arg1]) + [phoenix::bind(&definition::call_prop_actor) + (var(*this),a_list.key,a_list.value)],ch_p(',')); + + attr_list = +(ch_p('[') >> !a_list >> ch_p(']')); + + // RG - disregard port id's for now. + port_location + = (ch_p(':') >> ID) + | (ch_p(':') >> ch_p('(') >> ID >> ch_p(',') >> ID >> ch_p(')')) + ; + + port_angle = ch_p('@') >> ID; + + port + = port_location >> (!port_angle) + | port_angle >> (!port_location); + + + node_id + = ( ID[node_id.name = arg1] >> (!port) ) + [phoenix::bind(&definition::memoize_node)(var(*this))]; + + attr_stmt + = (as_lower_d[keyword_p("graph")] + >> attr_list(actor_t(phoenix::bind(&definition::default_graph_prop) + (var(*this),arg1,arg2)))) + | (as_lower_d[keyword_p("node")] + >> attr_list(actor_t(phoenix::bind(&definition::default_node_prop) + (var(*this),arg1,arg2)))) + | (as_lower_d[keyword_p("edge")] + >> attr_list(actor_t(phoenix::bind(&definition::default_edge_prop) + (var(*this),arg1,arg2)))) + ; + + // edge_head is set depending on the graph type (directed/undirected) + edgeop = ch_p('-') >> ch_p(boost::ref(edge_head)); + + edgeRHS + = +( edgeop[(data_stmt.sources = data_stmt.dests), + (data_stmt.dests = construct_())] + >> ( subgraph[data_stmt.dests = arg1] + | node_id[phoenix::bind(&definition::insert_node) + (var(*this),data_stmt.dests,arg1)] + ) + [phoenix::bind(&definition::activate_edge) + (var(*this),data_stmt.sources,data_stmt.dests, + var(edges), var(default_edge_props))] + ); + + + // To avoid backtracking, edge, node, and subgraph statements are + // processed as one nonterminal. + data_stmt + = ( subgraph[(data_stmt.dests = arg1),// will get moved in rhs + (data_stmt.saw_node = false)] + | node_id[(phoenix::bind(&definition::insert_node) + (var(*this),data_stmt.dests,arg1)), + (data_stmt.saw_node = true), +#ifdef BOOST_GRAPH_DEBUG + (std::cout << val("AcTive Node: ") << arg1 << "\n"), +#endif // BOOST_GRAPH_DEBUG + (data_stmt.active_node = arg1)] + ) >> if_p(edgeRHS)[ + !attr_list( + actor_t(phoenix::bind(&definition::edge_prop) + (var(*this),arg1,arg2))) + ].else_p[ + if_p(data_stmt.saw_node)[ + !attr_list( + actor_t(phoenix::bind(&definition::node_prop) + (var(*this),arg1,arg2))) + ] // otherwise it's a subgraph, nothing more to do. + ]; + + + stmt + = (ID >> ch_p('=') >> ID) // Graph property -- ignore. + | attr_stmt + | data_stmt + ; + + stmt_list = *( stmt >> !ch_p(';') ); + + subgraph + = !( as_lower_d[keyword_p("subgraph")] + >> (!ID[(subgraph.name = arg1), + (subgraph.nodes = (var(subgraph_nodes))[arg1]), + (subgraph.edges = (var(subgraph_edges))[arg1])]) + ) + >> ch_p('{')[++var(subgraph_depth)] + >> stmt_list + >> ch_p('}')[--var(subgraph_depth)] + [(var(subgraph_nodes))[subgraph.name] = subgraph.nodes] + [(var(subgraph_edges))[subgraph.name] = subgraph.edges] + + | as_lower_d[keyword_p("subgraph")] + >> ID[(subgraph.nodes = (var(subgraph_nodes))[arg1]), + (subgraph.edges = (var(subgraph_edges))[arg1])] + ; + + the_grammar + = (!as_lower_d[keyword_p("strict")]) + >> ( as_lower_d[keyword_p("graph")][ + (var(edge_head) = '-'), + (phoenix::bind(&definition::check_undirected)(var(*this)))] + | as_lower_d[keyword_p("digraph")][ + (var(edge_head) = '>'), + (phoenix::bind(&definition::check_directed)(var(*this)))] + ) + >> (!ID) >> ch_p('{') >> stmt_list >> ch_p('}'); + + } // definition() + + typedef rule rule_t; + + rule_t const& start() const { return the_grammar; } + + + // + // Semantic actions + // + + void check_undirected() { + if(self.graph_.is_directed()) + throw boost::undirected_graph_error(); + } + + void check_directed() { + if(!self.graph_.is_directed()) + throw boost::directed_graph_error(); + } + + void memoize_node() { + id_t const& node = node_id.name(); + props_t& node_props = default_node_props; + + if(nodes.find(node) == nodes.end()) { + nodes.insert(node); + self.graph_.do_add_vertex(node); + + node_map.insert(std::make_pair(node,ids_t())); + +#ifdef BOOST_GRAPH_DEBUG + std::cout << "Add new node " << node << std::endl; +#endif // BOOST_GRAPH_DEBUG + // Set the default properties for this edge + // RG: Here I would actually set the properties + for(props_t::iterator i = node_props.begin(); + i != node_props.end(); ++i) { + set_node_property(node,i->first,i->second); + } + if(subgraph_depth > 0) { + subgraph.nodes().insert(node); + // Set the subgraph's default properties as well + props_t& props = subgraph_node_props[subgraph.name()]; + for(props_t::iterator i = props.begin(); i != props.end(); ++i) { + set_node_property(node,i->first,i->second); + } + } + } else { +#ifdef BOOST_GRAPH_DEBUG + std::cout << "See node " << node << std::endl; +#endif // BOOST_GRAPH_DEBUG + } + } + + void activate_edge(nodes_t& sources, nodes_t& dests, edges_t& edges, + props_t& edge_props) { + edge_stack_t& edge_stack = data_stmt.edge_stack(); + for(nodes_t::iterator i = sources.begin(); i != sources.end(); ++i) { + for(nodes_t::iterator j = dests.begin(); j != dests.end(); ++j) { + // Create the edge and and push onto the edge stack. +#ifdef BOOST_GRAPH_DEBUG + std::cout << "Edge " << *i << " to " << *j << std::endl; +#endif // BOOST_GRAPH_DEBUG + + edge_t edge = edge_t::new_edge(); + edge_stack.push_back(edge); + edges.insert(edge); + edge_map.insert(std::make_pair(edge,ids_t())); + + // Add the real edge. + self.graph_.do_add_edge(edge, *i, *j); + + // Set the default properties for this edge + for(props_t::iterator k = edge_props.begin(); + k != edge_props.end(); ++k) { + set_edge_property(edge,k->first,k->second); + } + if(subgraph_depth > 0) { + subgraph.edges().insert(edge); + // Set the subgraph's default properties as well + props_t& props = subgraph_edge_props[subgraph.name()]; + for(props_t::iterator k = props.begin(); k != props.end(); ++k) { + set_edge_property(edge,k->first,k->second); + } + } + } + } + } + + // node_prop - Assign the property for the current active node. + void node_prop(id_t const& key, id_t const& value) { + node_t& active_object = data_stmt.active_node(); + set_node_property(active_object, key, value); + } + + // edge_prop - Assign the property for the current active edges. + void edge_prop(id_t const& key, id_t const& value) { + edge_stack_t const& active_edges_ = data_stmt.edge_stack(); + for (edge_stack_t::const_iterator i = active_edges_.begin(); + i != active_edges_.end(); ++i) { + set_edge_property(*i,key,value); + } + } + + // default_graph_prop - Just ignore graph properties. + void default_graph_prop(id_t const&, id_t const&) { } + + // default_node_prop - declare default properties for any future new nodes + void default_node_prop(id_t const& key, id_t const& value) { + nodes_t& nodes_ = + subgraph_depth == 0 ? nodes : subgraph.nodes(); + props_t& node_props_ = + subgraph_depth == 0 ? + default_node_props : + subgraph_node_props[subgraph.name()]; + + // add this to the selected list of default node properties. + node_props_[key] = value; + // for each node, set its property to default-constructed value + // if it hasn't been set already. + // set the dynamic property map value + for(nodes_t::iterator i = nodes_.begin(); i != nodes_.end(); ++i) + if(node_map[*i].find(key) == node_map[*i].end()) { + set_node_property(*i,key,id_t()); + } + } + + // default_edge_prop - declare default properties for any future new edges + void default_edge_prop(id_t const& key, id_t const& value) { + edges_t& edges_ = + subgraph_depth == 0 ? edges : subgraph.edges(); + props_t& edge_props_ = + subgraph_depth == 0 ? + default_edge_props : + subgraph_edge_props[subgraph.name()]; + + // add this to the list of default edge properties. + edge_props_[key] = value; + // for each edge, set its property to be empty string + // set the dynamic property map value + for(edges_t::iterator i = edges_.begin(); i != edges_.end(); ++i) + if(edge_map[*i].find(key) == edge_map[*i].end()) + set_edge_property(*i,key,id_t()); + } + + // helper function + void insert_node(nodes_t& nodes, id_t const& name) { + nodes.insert(name); + } + + void call_prop_actor(std::string const& lhs, std::string const& rhs) { + actor_t& actor = attr_list.prop_actor(); + // If first and last characters of the rhs are double-quotes, + // remove them. + if (!rhs.empty() && rhs[0] == '"' && rhs[rhs.size() - 1] == '"') + actor(lhs, rhs.substr(1, rhs.size()-2)); + else + actor(lhs,rhs); + } + + void set_node_property(node_t const& node, id_t const& key, + id_t const& value) { + + // Add the property key to the "set" table to avoid default overwrite + node_map[node].insert(key); + // Set the user's property map + self.graph_.set_node_property(key, node, value); +#ifdef BOOST_GRAPH_DEBUG + // Tell the world + std::cout << node << ": " << key << " = " << value << std::endl; +#endif // BOOST_GRAPH_DEBUG + } + + void set_edge_property(edge_t const& edge, id_t const& key, + id_t const& value) { + + // Add the property key to the "set" table to avoid default overwrite + edge_map[edge].insert(key); + // Set the user's property map + self.graph_.set_edge_property(key, edge, value); +#ifdef BOOST_GRAPH_DEBUG + // Tell the world + std::cout << "(" << edge.first << "," << edge.second << "): " + << key << " = " << value << std::endl; +#endif // BOOST_GRAPH_DEBUG + } + + // Variables explicitly initialized + dot_grammar const& self; + // if subgraph_depth > 0, then we're processing a subgraph. + int subgraph_depth; + + // Keywords; + const distinct_parser<> keyword_p; + // + // rules that make up the grammar + // + rule ID; + rule a_list; + rule attr_list; + rule_t port_location; + rule_t port_angle; + rule_t port; + rule node_id; + rule_t attr_stmt; + rule data_stmt; + rule subgraph; + rule_t edgeop; + rule_t edgeRHS; + rule_t stmt; + rule_t stmt_list; + rule_t the_grammar; + + + // The grammar uses edge_head to dynamically set the syntax for edges + // directed graphs: edge_head = '>', and so edgeop = "->" + // undirected graphs: edge_head = '-', and so edgeop = "--" + char edge_head; + + + // + // Support data structures + // + + nodes_t nodes; // list of node names seen + edges_t edges; // list of edges seen + node_map_t node_map; // remember the properties set for each node + edge_map_t edge_map; // remember the properties set for each edge + + subgraph_nodes_t subgraph_nodes; // per-subgraph lists of nodes + subgraph_edges_t subgraph_edges; // per-subgraph lists of edges + + props_t default_node_props; // global default node properties + props_t default_edge_props; // global default edge properties + subgraph_props_t subgraph_node_props; // per-subgraph default node properties + subgraph_props_t subgraph_edge_props; // per-subgraph default edge properties + }; // struct definition +}; // struct dot_grammar + + + +// +// dot_skipper - GraphViz whitespace and comment skipper +// +struct dot_skipper : public grammar +{ + dot_skipper() {} + + template + struct definition + { + definition(dot_skipper const& /*self*/) { + // comment forms + skip = space_p + | comment_p("//") + | comment_p("#") +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) + | confix_p(str_p("/*") ,*anychar_p, str_p("*/")) +#else + | confix_p("/*" ,*anychar_p, "*/") +#endif + ; + +#ifdef BOOST_SPIRIT_DEBUG + BOOST_SPIRIT_DEBUG_RULE(skip); +#endif + } + + rule skip; + rule const& + start() const { return skip; } + }; // definition +}; // dot_skipper + +} // namespace graph +} // namespace detail + +template +bool read_graphviz(MultiPassIterator begin, MultiPassIterator end, + MutableGraph& graph, dynamic_properties& dp, + std::string const& node_id = "node_id") { + using namespace boost; + using namespace boost::spirit; + + typedef MultiPassIterator iterator_t; + typedef skip_parser_iteration_policy< boost::detail::graph::dot_skipper> + iter_policy_t; + typedef scanner_policies scanner_policies_t; + typedef scanner scanner_t; + + detail::graph::mutate_graph_impl m_graph(graph, dp, node_id); + + boost::detail::graph::dot_grammar p(m_graph); + boost::detail::graph::dot_skipper skip_p; + + iter_policy_t iter_policy(skip_p); + scanner_policies_t policies(iter_policy); + + scanner_t scan(begin, end, policies); + + return p.parse(scan); +} + +} // namespace boost + +#endif // BOOST_READ_GRAPHVIZ_SPIRIT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/self_avoiding_walk.hpp b/deal.II/contrib/boost/include/boost/graph/detail/self_avoiding_walk.hpp new file mode 100644 index 0000000000..def0c6eef2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/self_avoiding_walk.hpp @@ -0,0 +1,418 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_SELF_AVOIDING_WALK_HPP +#define BOOST_SELF_AVOIDING_WALK_HPP + +/* + This file defines necessary components for SAW. + + mesh language: (defined by myself to clearify what is what) + A triangle in mesh is called an triangle. + An edge in mesh is called an line. + A vertex in mesh is called a point. + + A triangular mesh corresponds to a graph in which a vertex is a + triangle and an edge(u, v) stands for triangle u and triangle v + share an line. + + After this point, a vertex always refers to vertex in graph, + therefore it is a traingle in mesh. + + */ + +#include +#include +#include +#include + +#define SAW_SENTINAL -1 + +namespace boost { + + template + struct triple { + T1 first; + T2 second; + T3 third; + triple(const T1& a, const T2& b, const T3& c) : first(a), second(b), third(c) {} + triple() : first(SAW_SENTINAL), second(SAW_SENTINAL), third(SAW_SENTINAL) {} + }; + + typedef triple Triple; + + /* Define a vertex property which has a triangle inside. Triangle is + represented by a triple. */ + struct triangle_tag { enum { num = 100 }; }; + typedef property triangle_property; + + /* Define an edge property with a line. A line is represented by a + pair. This is not required for SAW though. + */ + struct line_tag { enum { num = 101 }; }; + template struct line_property + : public property > { }; + + /*Precondition: Points in a Triangle are in order */ + template + inline void get_sharing(const Triangle& a, const Triangle& b, Line& l) + { + l.first = SAW_SENTINAL; + l.second = SAW_SENTINAL; + + if ( a.first == b.first ) { + l.first = a.first; + if ( a.second == b.second || a.second == b.third ) + l.second = a.second; + else if ( a.third == b.second || a.third == b.third ) + l.second = a.third; + + } else if ( a.first == b.second ) { + l.first = a.first; + if ( a.second == b.third ) + l.second = a.second; + else if ( a.third == b.third ) + l.second = a.third; + + } else if ( a.first == b.third ) { + l.first = a.first; + + + } else if ( a.second == b.first ) { + l.first = a.second; + if ( a.third == b.second || a.third == b.third ) + l.second = a.third; + + } else if ( a.second == b.second ) { + l.first = a.second; + if ( a.third == b.third ) + l.second = a.third; + + } else if ( a.second == b.third ) { + l.first = a.second; + + + } else if ( a.third == b.first + || a.third == b.second + || a.third == b.third ) + l.first = a.third; + + /*Make it in order*/ + if ( l.first > l.second ) { + typename Line::first_type i = l.first; + l.first = l.second; + l.second = i; + } + + } + + template + struct get_vertex_sharing { + typedef std::pair Pair; + get_vertex_sharing(const TriangleDecorator& _td) : td(_td) {} + inline Line operator()(const Vertex& u, const Vertex& v) const { + Line l; + get_sharing(td[u], td[v], l); + return l; + } + inline Line operator()(const Pair& u, const Vertex& v) const { + Line l; + get_sharing(td[u.first], td[v], l); + return l; + } + inline Line operator()(const Pair& u, const Pair& v) const { + Line l; + get_sharing(td[u.first], td[v.first], l); + return l; + } + TriangleDecorator td; + }; + + /* HList has to be a handle of data holder so that pass-by-value is + * in right logic. + * + * The element of HList is a pair of vertex and line. (remember a + * line is a pair of two ints.). That indicates the walk w from + * current vertex is across line. (If the first of line is -1, it is + * a point though. + */ + template < class TriangleDecorator, class HList, class IteratorD> + class SAW_visitor + : public bfs_visitor<>, public dfs_visitor<> + { + typedef typename boost::property_traits::value_type iter; + /*use boost shared_ptr*/ + typedef typename HList::element_type::value_type::second_type Line; + public: + + typedef tree_edge_tag category; + + inline SAW_visitor(TriangleDecorator _td, HList _hlist, IteratorD ia) + : td(_td), hlist(_hlist), iter_d(ia) {} + + template + inline void start_vertex(Vertex v, Graph&) { + Line l1; + l1.first = SAW_SENTINAL; + l1.second = SAW_SENTINAL; + hlist->push_front(std::make_pair(v, l1)); + iter_d[v] = hlist->begin(); + } + + /*Several symbols: + w(i): i-th triangle in walk w + w(i) |- w(i+1): w enter w(i+1) from w(i) over a line + w(i) ~> w(i+1): w enter w(i+1) from w(i) over a point + w(i) -> w(i+1): w enter w(i+1) from w(i) + w(i) ^ w(i+1): the line or point w go over from w(i) to w(i+1) + */ + template + bool tree_edge(Edge e, Graph& G) { + using std::make_pair; + typedef typename boost::graph_traits::vertex_descriptor Vertex; + Vertex tau = target(e, G); + Vertex i = source(e, G); + + get_vertex_sharing get_sharing_line(td); + + Line tau_i = get_sharing_line(tau, i); + + iter w_end = hlist->end(); + + iter w_i = iter_d[i]; + + iter w_i_m_1 = w_i; + iter w_i_p_1 = w_i; + + /*---------------------------------------------------------- + * true false + *========================================================== + *a w(i-1) |- w(i) w(i-1) ~> w(i) or w(i-1) is null + *---------------------------------------------------------- + *b w(i) |- w(i+1) w(i) ~> w(i+1) or no w(i+1) yet + *---------------------------------------------------------- + */ + + bool a = false, b = false; + + --w_i_m_1; + ++w_i_p_1; + b = ( w_i->second.first != SAW_SENTINAL ); + + if ( w_i_m_1 != w_end ) { + a = ( w_i_m_1->second.first != SAW_SENTINAL ); + } + + if ( a ) { + + if ( b ) { + /*Case 1: + + w(i-1) |- w(i) |- w(i+1) + */ + Line l1 = get_sharing_line(*w_i_m_1, tau); + + iter w_i_m_2 = w_i_m_1; + --w_i_m_2; + + bool c = true; + + if ( w_i_m_2 != w_end ) { + c = w_i_m_2->second != l1; + } + + if ( c ) { /* w(i-1) ^ tau != w(i-2) ^ w(i-1) */ + /*extension: w(i-1) -> tau |- w(i) */ + w_i_m_1->second = l1; + /*insert(pos, const T&) is to insert before pos*/ + iter_d[tau] = hlist->insert(w_i, make_pair(tau, tau_i)); + + } else { /* w(i-1) ^ tau == w(i-2) ^ w(i-1) */ + /*must be w(i-2) ~> w(i-1) */ + + bool d = true; + //need to handle the case when w_i_p_1 is null + Line l3 = get_sharing_line(*w_i_p_1, tau); + if ( w_i_p_1 != w_end ) + d = w_i_p_1->second != l3; + if ( d ) { /* w(i+1) ^ tau != w(i+1) ^ w(i+2) */ + /*extension: w(i) |- tau -> w(i+1) */ + w_i->second = tau_i; + iter_d[tau] = hlist->insert(w_i_p_1, make_pair(tau, l3)); + } else { /* w(i+1) ^ tau == w(i+1) ^ w(i+2) */ + /*must be w(1+1) ~> w(i+2) */ + Line l5 = get_sharing_line(*w_i_m_1, *w_i_p_1); + if ( l5 != w_i_p_1->second ) { /* w(i-1) ^ w(i+1) != w(i+1) ^ w(i+2) */ + /*extension: w(i-2) -> tau |- w(i) |- w(i-1) -> w(i+1) */ + w_i_m_2->second = get_sharing_line(*w_i_m_2, tau); + iter_d[tau] = hlist->insert(w_i, make_pair(tau, tau_i)); + w_i->second = w_i_m_1->second; + w_i_m_1->second = l5; + iter_d[w_i_m_1->first] = hlist->insert(w_i_p_1, *w_i_m_1); + hlist->erase(w_i_m_1); + } else { + /*mesh is tetrahedral*/ + // dont know what that means. + ; + } + } + + } + } else { + /*Case 2: + + w(i-1) |- w(i) ~> w(1+1) + */ + + if ( w_i->second.second == tau_i.first + || w_i->second.second == tau_i.second ) { /*w(i) ^ w(i+1) < w(i) ^ tau*/ + /*extension: w(i) |- tau -> w(i+1) */ + w_i->second = tau_i; + Line l1 = get_sharing_line(*w_i_p_1, tau); + iter_d[tau] = hlist->insert(w_i_p_1, make_pair(tau, l1)); + } else { /*w(i) ^ w(i+1) !< w(i) ^ tau*/ + Line l1 = get_sharing_line(*w_i_m_1, tau); + bool c = true; + iter w_i_m_2 = w_i_m_1; + --w_i_m_2; + if ( w_i_m_2 != w_end ) + c = l1 != w_i_m_2->second; + if (c) { /*w(i-1) ^ tau != w(i-2) ^ w(i-1)*/ + /*extension: w(i-1) -> tau |- w(i)*/ + w_i_m_1->second = l1; + iter_d[tau] = hlist->insert(w_i, make_pair(tau, tau_i)); + } else { /*w(i-1) ^ tau == w(i-2) ^ w(i-1)*/ + /*must be w(i-2)~>w(i-1)*/ + /*extension: w(i-2) -> tau |- w(i) |- w(i-1) -> w(i+1)*/ + w_i_m_2->second = get_sharing_line(*w_i_m_2, tau); + iter_d[tau] = hlist->insert(w_i, make_pair(tau, tau_i)); + w_i->second = w_i_m_1->second; + w_i_m_1->second = get_sharing_line(*w_i_m_1, *w_i_p_1); + iter_d[w_i_m_1->first] = hlist->insert(w_i_p_1, *w_i_m_1); + hlist->erase(w_i_m_1); + } + + } + + } + + } else { + + if ( b ) { + /*Case 3: + + w(i-1) ~> w(i) |- w(i+1) + */ + bool c = false; + if ( w_i_m_1 != w_end ) + c = ( w_i_m_1->second.second == tau_i.first) + || ( w_i_m_1->second.second == tau_i.second); + + if ( c ) { /*w(i-1) ^ w(i) < w(i) ^ tau*/ + /* extension: w(i-1) -> tau |- w(i) */ + if ( w_i_m_1 != w_end ) + w_i_m_1->second = get_sharing_line(*w_i_m_1, tau); + iter_d[tau] = hlist->insert(w_i, make_pair(tau, tau_i)); + } else { + bool d = true; + Line l1; + l1.first = SAW_SENTINAL; + l1.second = SAW_SENTINAL; + if ( w_i_p_1 != w_end ) { + l1 = get_sharing_line(*w_i_p_1, tau); + d = l1 != w_i_p_1->second; + } + if (d) { /*w(i+1) ^ tau != w(i+1) ^ w(i+2)*/ + /*extension: w(i) |- tau -> w(i+1) */ + w_i->second = tau_i; + iter_d[tau] = hlist->insert(w_i_p_1, make_pair(tau, l1)); + } else { + /*must be w(i+1) ~> w(i+2)*/ + /*extension: w(i-1) -> w(i+1) |- w(i) |- tau -> w(i+2) */ + iter w_i_p_2 = w_i_p_1; + ++w_i_p_2; + + w_i_p_1->second = w_i->second; + iter_d[i] = hlist->insert(w_i_p_2, make_pair(i, tau_i)); + hlist->erase(w_i); + Line l2 = get_sharing_line(*w_i_p_2, tau); + iter_d[tau] = hlist->insert(w_i_p_2, make_pair(tau, l2)); + } + } + + } else { + /*Case 4: + + w(i-1) ~> w(i) ~> w(i+1) + + */ + bool c = false; + if ( w_i_m_1 != w_end ) { + c = (w_i_m_1->second.second == tau_i.first) + || (w_i_m_1->second.second == tau_i.second); + } + if ( c ) { /*w(i-1) ^ w(i) < w(i) ^ tau */ + /*extension: w(i-1) -> tau |- w(i) */ + if ( w_i_m_1 != w_end ) + w_i_m_1->second = get_sharing_line(*w_i_m_1, tau); + iter_d[tau] = hlist->insert(w_i, make_pair(tau, tau_i)); + } else { + /*extension: w(i) |- tau -> w(i+1) */ + w_i->second = tau_i; + Line l1; + l1.first = SAW_SENTINAL; + l1.second = SAW_SENTINAL; + if ( w_i_p_1 != w_end ) + l1 = get_sharing_line(*w_i_p_1, tau); + iter_d[tau] = hlist->insert(w_i_p_1, make_pair(tau, l1)); + } + } + + } + + return true; + } + + protected: + TriangleDecorator td; /*a decorator for vertex*/ + HList hlist; + /*This must be a handle of list to record the SAW + The element type of the list is pair + */ + + IteratorD iter_d; + /*Problem statement: Need a fast access to w for triangle i. + *Possible solution: mantain an array to record. + iter_d[i] will return an iterator + which points to w(i), where i is a vertex + representing triangle i. + */ + }; + + template + inline + SAW_visitor + visit_SAW(Triangle t, HList hl, Iterator i) { + return SAW_visitor(t, hl, i); + } + + template + inline + SAW_visitor< random_access_iterator_property_map, + HList, random_access_iterator_property_map > + visit_SAW_ptr(Tri* t, HList hl, Iter* i) { + typedef random_access_iterator_property_map TriD; + typedef random_access_iterator_property_map IterD; + return SAW_visitor(t, hl, i); + } + + // should also have combo's of pointers, and also const :( + +} + +#endif /*BOOST_SAW_H*/ diff --git a/deal.II/contrib/boost/include/boost/graph/detail/set_adaptor.hpp b/deal.II/contrib/boost/include/boost/graph/detail/set_adaptor.hpp new file mode 100644 index 0000000000..eb81dbba86 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/set_adaptor.hpp @@ -0,0 +1,117 @@ +// (C) Copyright Jeremy Siek 2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_SET_ADAPTOR_HPP +#define BOOST_SET_ADAPTOR_HPP + +#include + +namespace boost { + + template + bool set_contains(const std::set& s, const T& x) { + return s.find(x) != s.end(); + } + + template + bool set_equal(const std::set& x, + const std::set& y) + { + return x == y; + } + + // Not the same as lexicographical_compare_3way applied to std::set. + // this is equivalent semantically to bitset::operator<() + template + int set_lex_order(const std::set& x, + const std::set& y) + { + typename std::set::iterator + xi = x.begin(), yi = y.begin(), xend = x.end(), yend = y.end(); + for (; xi != xend && yi != yend; ++xi, ++yi) { + if (*xi < *yi) + return 1; + else if (*yi < *xi) + return -1; + } + if (xi == xend) + return (yi == yend) ? 0 : -1; + else + return 1; + } + + template + void set_clear(std::set& x) { + x.clear(); + } + + template + bool set_empty(const std::set& x) { + return x.empty(); + } + + template + void set_insert(std::set& x, const T& a) { + x.insert(a); + } + + template + void set_remove(std::set& x, const T& a) { + x.erase(a); + } + + template + void set_intersect(const std::set& x, + const std::set& y, + std::set& z) + { + z.clear(); + std::set_intersection(x.begin(), x.end(), + y.begin(), y.end(), + std::inserter(z)); + } + + template + void set_union(const std::set& x, + const std::set& y, + std::set& z) + { + z.clear(); + std::set_union(x.begin(), x.end(), + y.begin(), y.end(), + std::inserter(z)); + } + + template + void set_difference(const std::set& x, + const std::set& y, + std::set& z) + { + z.clear(); + std::set_difference(x.begin(), x.end(), + y.begin(), y.end(), + std::inserter(z, z.begin())); + } + + template + bool set_subset(const std::set& x, + const std::set& y) + { + return std::includes(x.begin(), x.end(), y.begin(), y.end()); + } + + // Shit, can't implement this without knowing the size of the + // universe. + template + void set_compliment(const std::set& x, + std::set& z) + { + z.clear(); + + } + +} // namespace boost + +#endif // BOOST_SET_ADAPTOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/shadow_iterator.hpp b/deal.II/contrib/boost/include/boost/graph/detail/shadow_iterator.hpp new file mode 100644 index 0000000000..6cd15384fc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/shadow_iterator.hpp @@ -0,0 +1,139 @@ +// (C) Copyright Jeremy Siek 2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_SHADOW_ITERATOR_HPP +#define BOOST_SHADOW_ITERATOR_HPP + +#include +#include + +namespace boost { + + namespace detail { + + template + class shadow_proxy + : boost::operators< shadow_proxy > + { + typedef shadow_proxy self; + public: + inline shadow_proxy(A aa, B bb) : a(aa), b(bb) { } + inline shadow_proxy(const self& x) : a(x.a), b(x.b) { } + template + inline shadow_proxy(Self x) : a(x.a), b(x.b) { } + inline self& operator=(const self& x) { a = x.a; b = x.b; return *this; } + inline self& operator++() { ++a; return *this; } + inline self& operator--() { --a; return *this; } + inline self& operator+=(const self& x) { a += x.a; return *this; } + inline self& operator-=(const self& x) { a -= x.a; return *this; } + inline self& operator*=(const self& x) { a *= x.a; return *this; } + inline self& operator/=(const self& x) { a /= x.a; return *this; } + inline self& operator%=(const self& x) { return *this; } // JGS + inline self& operator&=(const self& x) { return *this; } // JGS + inline self& operator|=(const self& x) { return *this; } // JGS + inline self& operator^=(const self& x) { return *this; } // JGS + inline friend D operator-(const self& x, const self& y) { + return x.a - y.a; + } + inline bool operator==(const self& x) const { return a == x.a; } + inline bool operator<(const self& x) const { return a < x.a; } + // protected: + A a; + B b; + }; + + struct shadow_iterator_policies + { + template + void initialize(const iter_pair&) { } + + template + typename Iter::reference dereference(const Iter& i) const { + typedef typename Iter::reference R; + return R(*i.base().first, *i.base().second); + } + template + bool equal(const Iter& p1, const Iter& p2) const { + return p1.base().first == p2.base().first; + } + template + void increment(Iter& i) { ++i.base().first; ++i.base().second; } + + template + void decrement(Iter& i) { --i.base().first; --i.base().second; } + + template + bool less(const Iter& x, const Iter& y) const { + return x.base().first < y.base().first; + } + template + typename Iter::difference_type + distance(const Iter& x, const Iter& y) const { + return y.base().first - x.base().first; + } + template + void advance(Iter& p, D n) { p.base().first += n; p.base().second += n; } + }; + + } // namespace detail + + template + struct shadow_iterator_generator { + + // To use the iterator_adaptor we can't derive from + // random_access_iterator because we don't have a real reference. + // However, we want the STL algorithms to treat the shadow + // iterator like a random access iterator. + struct shadow_iterator_tag : public std::input_iterator_tag { + operator std::random_access_iterator_tag() { + return std::random_access_iterator_tag(); + }; + }; + typedef typename std::iterator_traits::value_type Aval; + typedef typename std::iterator_traits::value_type Bval; + typedef typename std::iterator_traits::reference Aref; + typedef typename std::iterator_traits::reference Bref; + typedef typename std::iterator_traits::difference_type D; + typedef detail::shadow_proxy V; + typedef detail::shadow_proxy R; + typedef iterator_adaptor< std::pair, + detail::shadow_iterator_policies, + V, R, V*, shadow_iterator_tag, + D> type; + }; + + // short cut for creating a shadow iterator + template + inline typename shadow_iterator_generator::type + make_shadow_iter(IterA a, IterB b) { + typedef typename shadow_iterator_generator::type Iter; + return Iter(std::make_pair(a,b)); + } + + template + struct shadow_cmp { + inline shadow_cmp(const Cmp& c) : cmp(c) { } + template + inline bool operator()(const ShadowProxy1& x, const ShadowProxy2& y) const + { + return cmp(x.a, y.a); + } + Cmp cmp; + }; + +} // namespace boost + +namespace std { + template + void swap(boost::detail::shadow_proxy x, + boost::detail::shadow_proxy y) + { + std::swap(x.a, y.a); + std::swap(x.b, y.b); + } +} + +#endif // BOOST_SHADOW_ITERATOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/detail/sparse_ordering.hpp b/deal.II/contrib/boost/include/boost/graph/detail/sparse_ordering.hpp new file mode 100644 index 0000000000..1124531466 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/detail/sparse_ordering.hpp @@ -0,0 +1,214 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// +#ifndef BOOST_GRAPH_DETAIL_SPARSE_ORDERING_HPP +#define BOOST_GRAPH_DETAIL_SPARSE_ORDERING_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + namespace sparse { + + // rcm_queue + // + // This is a custom queue type used in the + // *_ordering algorithms. + // In addition to the normal queue operations, the + // rcm_queue provides: + // + // int eccentricity() const; + // value_type spouse() const; + // + + // yes, it's a bad name...but it works, so use it + template < class Vertex, class DegreeMap, + class Container = std::deque > + class rcm_queue : public std::queue { + typedef std::queue base; + public: + typedef typename base::value_type value_type; + typedef typename base::size_type size_type; + + /* SGI queue has not had a contructor queue(const Container&) */ + inline rcm_queue(DegreeMap deg) + : _size(0), Qsize(1), eccen(-1), degree(deg) { } + + inline void pop() { + if ( !_size ) + Qsize = base::size(); + + base::pop(); + if ( _size == Qsize-1 ) { + _size = 0; + ++eccen; + } else + ++_size; + + } + + inline value_type& front() { + value_type& u = base::front(); + if ( _size == 0 ) + w = u; + else if (get(degree,u) < get(degree,w) ) + w = u; + return u; + } + + inline const value_type& front() const { + const value_type& u = base::front(); + if ( _size == 0 ) + w = u; + else if (get(degree,u) < get(degree,w) ) + w = u; + return u; + } + + inline value_type& top() { return front(); } + inline const value_type& top() const { return front(); } + + inline size_type size() const { return base::size(); } + + inline size_type eccentricity() const { return eccen; } + inline value_type spouse() const { return w; } + + protected: + size_type _size; + size_type Qsize; + int eccen; + mutable value_type w; + DegreeMap degree; + }; + + + template > + class sparse_ordering_queue : public boost::queue{ + public: + typedef typename Sequence::iterator iterator; + typedef typename Sequence::reverse_iterator reverse_iterator; + typedef queue queue; + typedef typename Sequence::size_type size_type; + + inline iterator begin() { return this->c.begin(); } + inline reverse_iterator rbegin() { return this->c.rbegin(); } + inline iterator end() { return this->c.end(); } + inline reverse_iterator rend() { return this->c.rend(); } + inline Tp &operator[](int n) { return this->c[n]; } + inline size_type size() {return this->c.size(); } + protected: + //nothing + }; + + } // namespace sparse + + // Compute Pseudo peripheral + // + // To compute an approximated peripheral for a given vertex. + // Used in king_ordering algorithm. + // + template + Vertex + pseudo_peripheral_pair(Graph& G, const Vertex& u, int& ecc, + ColorMap color, DegreeMap degree) + { + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + sparse::rcm_queue Q(degree); + + typename boost::graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) + if (get(color, *ui) != Color::red()) put(color, *ui, Color::white()); + breadth_first_visit(G, u, buffer(Q).color_map(color)); + + ecc = Q.eccentricity(); + return Q.spouse(); + } + + // Find a good starting node + // + // This is to find a good starting node for the + // king_ordering algorithm. "good" is in the sense + // of the ordering generated by RCM. + // + template + Vertex find_starting_node(Graph& G, Vertex r, Color color, Degree degree) + { + Vertex x, y; + int eccen_r, eccen_x; + + x = pseudo_peripheral_pair(G, r, eccen_r, color, degree); + y = pseudo_peripheral_pair(G, x, eccen_x, color, degree); + + while (eccen_x > eccen_r) { + r = x; + eccen_r = eccen_x; + x = y; + y = pseudo_peripheral_pair(G, x, eccen_x, color, degree); + } + return x; + } + +template +class out_degree_property_map + : public put_get_helper::degree_size_type, + out_degree_property_map > +{ +public: + typedef typename graph_traits::vertex_descriptor key_type; + typedef typename graph_traits::degree_size_type value_type; + typedef value_type reference; + typedef readable_property_map_tag category; + out_degree_property_map(const Graph& g) : m_g(g) { } + value_type operator[](const key_type& v) const { + return out_degree(v, m_g); + } +private: + const Graph& m_g; +}; +template +inline out_degree_property_map +make_out_degree_map(const Graph& g) { + return out_degree_property_map(g); +} + +} // namespace boost + + +#endif // BOOST_GRAPH_KING_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/dijkstra_shortest_paths.hpp b/deal.II/contrib/boost/include/boost/graph/dijkstra_shortest_paths.hpp new file mode 100644 index 0000000000..95a995c12f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/dijkstra_shortest_paths.hpp @@ -0,0 +1,346 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DIJKSTRA_HPP +#define BOOST_GRAPH_DIJKSTRA_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_GRAPH_DIJKSTRA_TESTING +# include +#endif // BOOST_GRAPH_DIJKSTRA_TESTING + +namespace boost { + +#ifdef BOOST_GRAPH_DIJKSTRA_TESTING + static bool dijkstra_relaxed_heap = true; +#endif + + template + struct DijkstraVisitorConcept { + void constraints() { + function_requires< CopyConstructibleConcept >(); + vis.discover_vertex(u, g); + vis.examine_vertex(u, g); + vis.examine_edge(e, g); + vis.edge_relaxed(e, g); + vis.edge_not_relaxed(e, g); + vis.finish_vertex(u, g); + } + Visitor vis; + Graph g; + typename graph_traits::vertex_descriptor u; + typename graph_traits::edge_descriptor e; + }; + + template + class dijkstra_visitor : public bfs_visitor { + public: + dijkstra_visitor() { } + dijkstra_visitor(Visitors vis) + : bfs_visitor(vis) { } + + template + void edge_relaxed(Edge e, Graph& g) { + invoke_visitors(this->m_vis, e, g, on_edge_relaxed()); + } + template + void edge_not_relaxed(Edge e, Graph& g) { + invoke_visitors(this->m_vis, e, g, on_edge_not_relaxed()); + } + private: + template + void tree_edge(Edge u, Graph& g) { } + }; + template + dijkstra_visitor + make_dijkstra_visitor(Visitors vis) { + return dijkstra_visitor(vis); + } + typedef dijkstra_visitor<> default_dijkstra_visitor; + + namespace detail { + + template + struct dijkstra_bfs_visitor + { + typedef typename property_traits::value_type D; + + dijkstra_bfs_visitor(UniformCostVisitor vis, UpdatableQueue& Q, + WeightMap w, PredecessorMap p, DistanceMap d, + BinaryFunction combine, BinaryPredicate compare, + D zero) + : m_vis(vis), m_Q(Q), m_weight(w), m_predecessor(p), m_distance(d), + m_combine(combine), m_compare(compare), m_zero(zero) { } + + template + void tree_edge(Edge e, Graph& g) { + m_decreased = relax(e, g, m_weight, m_predecessor, m_distance, + m_combine, m_compare); + if (m_decreased) + m_vis.edge_relaxed(e, g); + else + m_vis.edge_not_relaxed(e, g); + } + template + void gray_target(Edge e, Graph& g) { + m_decreased = relax(e, g, m_weight, m_predecessor, m_distance, + m_combine, m_compare); + if (m_decreased) { + m_Q.update(target(e, g)); + m_vis.edge_relaxed(e, g); + } else + m_vis.edge_not_relaxed(e, g); + } + + template + void initialize_vertex(Vertex u, Graph& g) + { m_vis.initialize_vertex(u, g); } + template + void non_tree_edge(Edge, Graph&) { } + template + void discover_vertex(Vertex u, Graph& g) { m_vis.discover_vertex(u, g); } + template + void examine_vertex(Vertex u, Graph& g) { m_vis.examine_vertex(u, g); } + template + void examine_edge(Edge e, Graph& g) { + if (m_compare(get(m_weight, e), m_zero)) + throw negative_edge(); + m_vis.examine_edge(e, g); + } + template + void black_target(Edge, Graph&) { } + template + void finish_vertex(Vertex u, Graph& g) { m_vis.finish_vertex(u, g); } + + UniformCostVisitor m_vis; + UpdatableQueue& m_Q; + WeightMap m_weight; + PredecessorMap m_predecessor; + DistanceMap m_distance; + BinaryFunction m_combine; + BinaryPredicate m_compare; + bool m_decreased; + D m_zero; + }; + + } // namespace detail + + // Call breadth first search with default color map. + template + inline void + dijkstra_shortest_paths_no_init + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + PredecessorMap predecessor, DistanceMap distance, WeightMap weight, + IndexMap index_map, + Compare compare, Combine combine, DistZero zero, + DijkstraVisitor vis) + { + std::vector color(num_vertices(g)); + default_color_type c = white_color; + dijkstra_shortest_paths_no_init( g, s, predecessor, distance, weight, + index_map, compare, combine, zero, vis, + make_iterator_property_map(&color[0], index_map, c)); + } + + // Call breadth first search + template + inline void + dijkstra_shortest_paths_no_init + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + PredecessorMap predecessor, DistanceMap distance, WeightMap weight, + IndexMap index_map, + Compare compare, Combine combine, DistZero zero, + DijkstraVisitor vis, ColorMap color) + { + typedef indirect_cmp IndirectCmp; + IndirectCmp icmp(distance, compare); + + typedef typename graph_traits::vertex_descriptor Vertex; + +#ifdef BOOST_GRAPH_DIJKSTRA_TESTING + if (!dijkstra_relaxed_heap) { + typedef mutable_queue, IndirectCmp, IndexMap> + MutableQueue; + + MutableQueue Q(num_vertices(g), icmp, index_map); + + detail::dijkstra_bfs_visitor + bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero); + + breadth_first_visit(g, s, Q, bfs_vis, color); + return; + } +#endif // BOOST_GRAPH_DIJKSTRA_TESTING + + typedef relaxed_heap MutableQueue; + + MutableQueue Q(num_vertices(g), icmp, index_map); + + detail::dijkstra_bfs_visitor + bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero); + + breadth_first_visit(g, s, Q, bfs_vis, color); + } + + // Initialize distances and call breadth first search with default color map + template + inline void + dijkstra_shortest_paths + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + PredecessorMap predecessor, DistanceMap distance, WeightMap weight, + IndexMap index_map, + Compare compare, Combine combine, DistInf inf, DistZero zero, + DijkstraVisitor vis) + { + std::vector color(num_vertices(g)); + default_color_type c = white_color; + dijkstra_shortest_paths(g, s, predecessor, distance, weight, index_map, + compare, combine, inf, zero, vis, + make_iterator_property_map(&color[0], index_map, + c)); + } + + // Initialize distances and call breadth first search + template + inline void + dijkstra_shortest_paths + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + PredecessorMap predecessor, DistanceMap distance, WeightMap weight, + IndexMap index_map, + Compare compare, Combine combine, DistInf inf, DistZero zero, + DijkstraVisitor vis, ColorMap color) + { + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + put(distance, *ui, inf); + put(predecessor, *ui, *ui); + put(color, *ui, Color::white()); + } + put(distance, s, zero); + + dijkstra_shortest_paths_no_init(g, s, predecessor, distance, weight, + index_map, compare, combine, zero, vis, color); + } + + namespace detail { + + // Handle defaults for PredecessorMap and + // Distance Compare, Combine, Inf and Zero + template + inline void + dijkstra_dispatch2 + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + DistanceMap distance, WeightMap weight, IndexMap index_map, + const Params& params, ColorMap color) + { + // Default for predecessor map + dummy_property_map p_map; + + typedef typename property_traits::value_type D; + dijkstra_shortest_paths + (g, s, + choose_param(get_param(params, vertex_predecessor), p_map), + distance, weight, index_map, + choose_param(get_param(params, distance_compare_t()), + std::less()), + choose_param(get_param(params, distance_combine_t()), + closed_plus()), + choose_param(get_param(params, distance_inf_t()), + (std::numeric_limits::max)()), + choose_param(get_param(params, distance_zero_t()), + D()), + choose_param(get_param(params, graph_visitor), + make_dijkstra_visitor(null_visitor())), + color); + } + + template + inline void + dijkstra_dispatch1 + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + DistanceMap distance, WeightMap weight, IndexMap index_map, + const Params& params, ColorMap color) + { + // Default for distance map + typedef typename property_traits::value_type D; + typename std::vector::size_type + n = is_default_param(distance) ? num_vertices(g) : 1; + std::vector distance_map(n); + + // Default for color map + typename std::vector::size_type + m = is_default_param(color) ? num_vertices(g) : 1; + std::vector color_map(m); + + detail::dijkstra_dispatch2 + (g, s, choose_param(distance, make_iterator_property_map + (distance_map.begin(), index_map, + distance_map[0])), + weight, index_map, params, + choose_param(color, make_iterator_property_map + (color_map.begin(), index_map, + color_map[0]))); + } + } // namespace detail + + // Named Parameter Variant + template + inline void + dijkstra_shortest_paths + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params) + { + // Default for edge weight and vertex index map is to ask for them + // from the graph. Default for the visitor is null_visitor. + detail::dijkstra_dispatch1 + (g, s, + get_param(params, vertex_distance), + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index), + params, + get_param(params, vertex_color)); + } + +} // namespace boost + +#endif // BOOST_GRAPH_DIJKSTRA_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/edge_connectivity.hpp b/deal.II/contrib/boost/include/boost/graph/edge_connectivity.hpp new file mode 100644 index 0000000000..d78e3ee41a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/edge_connectivity.hpp @@ -0,0 +1,181 @@ +//======================================================================= +// Copyright 2000 University of Notre Dame. +// Authors: Jeremy G. Siek, Andrew Lumsdaine, Lie-Quan Lee +// +// 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_EDGE_CONNECTIVITY +#define BOOST_EDGE_CONNECTIVITY + +// WARNING: not-yet fully tested! + +#include +#include +#include +#include +#include + +namespace boost { + + namespace detail { + + template + inline + std::pair::vertex_descriptor, + typename graph_traits::degree_size_type> + min_degree_vertex(Graph& g) + { + typedef graph_traits Traits; + typename Traits::vertex_descriptor p; + typedef typename Traits::degree_size_type size_type; + size_type delta = (std::numeric_limits::max)(); + + typename Traits::vertex_iterator i, iend; + for (tie(i, iend) = vertices(g); i != iend; ++i) + if (degree(*i, g) < delta) { + delta = degree(*i, g); + p = *i; + } + return std::make_pair(p, delta); + } + + template + void neighbors(const Graph& g, + typename graph_traits::vertex_descriptor u, + OutputIterator result) + { + typename graph_traits::adjacency_iterator ai, aend; + for (tie(ai, aend) = adjacent_vertices(u, g); ai != aend; ++ai) + *result++ = *ai; + } + + template + void neighbors(const Graph& g, + VertexIterator first, VertexIterator last, + OutputIterator result) + { + for (; first != last; ++first) + neighbors(g, *first, result); + } + + } // namespace detail + + // O(m n) + template + typename graph_traits::degree_size_type + edge_connectivity(VertexListGraph& g, OutputIterator disconnecting_set) + { + //------------------------------------------------------------------------- + // Type Definitions + typedef graph_traits Traits; + typedef typename Traits::vertex_iterator vertex_iterator; + typedef typename Traits::edge_iterator edge_iterator; + typedef typename Traits::out_edge_iterator out_edge_iterator; + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::degree_size_type degree_size_type; + typedef color_traits Color; + + typedef adjacency_list_traits Tr; + typedef typename Tr::edge_descriptor Tr_edge_desc; + typedef adjacency_list > > > + FlowGraph; + typedef typename graph_traits::edge_descriptor edge_descriptor; + + //------------------------------------------------------------------------- + // Variable Declarations + vertex_descriptor u, v, p, k; + edge_descriptor e1, e2; + bool inserted; + vertex_iterator vi, vi_end; + edge_iterator ei, ei_end; + degree_size_type delta, alpha_star, alpha_S_k; + std::set S, neighbor_S; + std::vector S_star, non_neighbor_S; + std::vector color(num_vertices(g)); + std::vector pred(num_vertices(g)); + + //------------------------------------------------------------------------- + // Create a network flow graph out of the undirected graph + FlowGraph flow_g(num_vertices(g)); + + typename property_map::type + cap = get(edge_capacity, flow_g); + typename property_map::type + res_cap = get(edge_residual_capacity, flow_g); + typename property_map::type + rev_edge = get(edge_reverse, flow_g); + + for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) { + u = source(*ei, g), v = target(*ei, g); + tie(e1, inserted) = add_edge(u, v, flow_g); + cap[e1] = 1; + tie(e2, inserted) = add_edge(v, u, flow_g); + cap[e2] = 1; // not sure about this + rev_edge[e1] = e2; + rev_edge[e2] = e1; + } + + //------------------------------------------------------------------------- + // The Algorithm + + tie(p, delta) = detail::min_degree_vertex(g); + S_star.push_back(p); + alpha_star = delta; + S.insert(p); + neighbor_S.insert(p); + detail::neighbors(g, S.begin(), S.end(), + std::inserter(neighbor_S, neighbor_S.begin())); + + std::set_difference(vertices(g).first, vertices(g).second, + neighbor_S.begin(), neighbor_S.end(), + std::back_inserter(non_neighbor_S)); + + while (!non_neighbor_S.empty()) { // at most n - 1 times + k = non_neighbor_S.front(); + + alpha_S_k = edmunds_karp_max_flow + (flow_g, p, k, cap, res_cap, rev_edge, &color[0], &pred[0]); + + if (alpha_S_k < alpha_star) { + alpha_star = alpha_S_k; + S_star.clear(); + for (tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi) + if (color[*vi] != Color::white()) + S_star.push_back(*vi); + } + S.insert(k); + neighbor_S.insert(k); + detail::neighbors(g, k, std::inserter(neighbor_S, neighbor_S.begin())); + non_neighbor_S.clear(); + std::set_difference(vertices(g).first, vertices(g).second, + neighbor_S.begin(), neighbor_S.end(), + std::back_inserter(non_neighbor_S)); + } + //------------------------------------------------------------------------- + // Compute edges of the cut [S*, ~S*] + std::vector in_S_star(num_vertices(g), false); + typename std::vector::iterator si; + for (si = S_star.begin(); si != S_star.end(); ++si) + in_S_star[*si] = true; + + degree_size_type c = 0; + for (si = S_star.begin(); si != S_star.end(); ++si) { + out_edge_iterator ei, ei_end; + for (tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei) + if (!in_S_star[target(*ei, g)]) { + *disconnecting_set++ = *ei; + ++c; + } + } + return c; + } + +} // namespace boost + +#endif // BOOST_EDGE_CONNECTIVITY diff --git a/deal.II/contrib/boost/include/boost/graph/edge_list.hpp b/deal.II/contrib/boost/include/boost/graph/edge_list.hpp new file mode 100644 index 0000000000..46fdde69ee --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/edge_list.hpp @@ -0,0 +1,303 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_EDGE_LIST_HPP +#define BOOST_GRAPH_EDGE_LIST_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + + // + // The edge_list class is an EdgeListGraph module that is constructed + // from a pair of iterators whose value type is a pair of vertex + // descriptors. + // + // For example: + // + // typedef std::pair E; + // list elist; + // ... + // typedef edge_list::iterator> Graph; + // Graph g(elist.begin(), elist.end()); + // + // If the iterators are random access, then Graph::edge_descriptor + // is of Integral type, otherwise it is a struct, though it is + // convertible to an Integral type. + // + + struct edge_list_tag { }; + + // The implementation class for edge_list. + template + class edge_list_impl + { + public: + typedef D edge_id; + typedef T Vpair; + typedef typename Vpair::first_type V; + typedef V vertex_descriptor; + typedef edge_list_tag graph_tag; + typedef void edge_property_type; + + struct edge_descriptor + { + edge_descriptor() { } + edge_descriptor(EdgeIter p, edge_id id) : _ptr(p), _id(id) { } + operator edge_id() { return _id; } + EdgeIter _ptr; + edge_id _id; + }; + typedef edge_descriptor E; + + struct edge_iterator + { + typedef edge_iterator self; + typedef E value_type; + typedef E& reference; + typedef E* pointer; + typedef std::ptrdiff_t difference_type; + typedef std::input_iterator_tag iterator_category; + edge_iterator() { } + edge_iterator(EdgeIter iter) : _iter(iter), _i(0) { } + E operator*() { return E(_iter, _i); } + self& operator++() { ++_iter; ++_i; return *this; } + self operator++(int) { self t = *this; ++(*this); return t; } + bool operator==(const self& x) { return _iter == x._iter; } + bool operator!=(const self& x) { return _iter != x._iter; } + EdgeIter _iter; + edge_id _i; + }; + typedef void out_edge_iterator; + typedef void in_edge_iterator; + typedef void adjacency_iterator; + typedef void vertex_iterator; + }; + + template + std::pair::edge_iterator, + typename edge_list_impl::edge_iterator> + edges(const edge_list_impl& g_) { + const G& g = static_cast(g_); + typedef typename edge_list_impl::edge_iterator edge_iterator; + return std::make_pair(edge_iterator(g._first), edge_iterator(g._last)); + } + template + typename edge_list_impl::vertex_descriptor + source(typename edge_list_impl::edge_descriptor e, + const edge_list_impl&) { + return (*e._ptr).first; + } + template + typename edge_list_impl::vertex_descriptor + target(typename edge_list_impl::edge_descriptor e, + const edge_list_impl&) { + return (*e._ptr).second; + } + + template + class el_edge_property_map + : public put_get_helper >{ + public: + typedef E key_type; + typedef D value_type; + typedef D reference; + typedef readable_property_map_tag category; + + value_type operator[](key_type e) const { + return e._i; + } + }; + struct edge_list_edge_property_selector { + template + struct bind_ { + typedef el_edge_property_map type; + typedef type const_type; + }; + }; + template <> + struct edge_property_selector { + typedef edge_list_edge_property_selector type; + }; + + template + typename property_map< edge_list_impl, edge_index_t>::type + get(edge_index_t, const edge_list_impl&) { + typedef typename property_map< edge_list_impl, + edge_index_t>::type EdgeIndexMap; + return EdgeIndexMap(); + } + + template + inline D + get(edge_index_t, const edge_list_impl&, + typename edge_list_impl::edge_descriptor e) { + return e._i; + } + + // A specialized implementation for when the iterators are random access. + + struct edge_list_ra_tag { }; + + template + class edge_list_impl_ra + { + public: + typedef D edge_id; + typedef T Vpair; + typedef typename Vpair::first_type V; + typedef edge_list_ra_tag graph_tag; + typedef void edge_property_type; + + typedef edge_id edge_descriptor; + typedef V vertex_descriptor; + typedef typename boost::integer_range::iterator edge_iterator; + typedef void out_edge_iterator; + typedef void in_edge_iterator; + typedef void adjacency_iterator; + typedef void vertex_iterator; + }; + + template + std::pair::edge_iterator, + typename edge_list_impl_ra::edge_iterator> + edges(const edge_list_impl_ra& g_) + { + const G& g = static_cast(g_); + typedef typename edge_list_impl_ra::edge_iterator edge_iterator; + return std::make_pair(edge_iterator(0), edge_iterator(g._last - g._first)); + } + template + typename edge_list_impl_ra::vertex_descriptor + source(typename edge_list_impl_ra::edge_descriptor e, + const edge_list_impl_ra& g_) + { + const G& g = static_cast(g_); + return g._first[e].first; + } + template + typename edge_list_impl_ra::vertex_descriptor + target(typename edge_list_impl_ra::edge_descriptor e, + const edge_list_impl_ra& g_) + { + const G& g = static_cast(g_); + return g._first[e].second; + } + template + class el_ra_edge_property_map + : public put_get_helper >{ + public: + typedef E key_type; + typedef E value_type; + typedef E reference; + typedef readable_property_map_tag category; + + value_type operator[](key_type e) const { + return e; + } + }; + struct edge_list_ra_edge_property_selector { + template + struct bind_ { + typedef el_ra_edge_property_map type; + typedef type const_type; + }; + }; + template <> + struct edge_property_selector { + typedef edge_list_ra_edge_property_selector type; + }; + template + inline + typename property_map< edge_list_impl_ra, edge_index_t>::type + get(edge_index_t, const edge_list_impl_ra&) { + typedef typename property_map< edge_list_impl_ra, + edge_index_t>::type EdgeIndexMap; + return EdgeIndexMap(); + } + + template + inline D + get(edge_index_t, const edge_list_impl_ra&, + typename edge_list_impl_ra::edge_descriptor e) { + return e; + } + + + // Some helper classes for determining if the iterators are random access + template + struct is_random { + enum { RET = false }; + typedef false_type type; + }; + template <> + struct is_random { + enum { RET = true }; typedef true_type type; + }; + + // The edge_list class conditionally inherits from one of the + // above two classes. + + template ::value_type, + class D = typename std::iterator_traits::difference_type, + class Cat = typename std::iterator_traits::iterator_category> +#else + class T, + class D, + class Cat> +#endif + class edge_list + : public ct_if_t< typename is_random::type, + edge_list_impl_ra< edge_list, EdgeIter,T,D>, + edge_list_impl< edge_list, EdgeIter,T,D> + >::type + { + public: + typedef directed_tag directed_category; + typedef allow_parallel_edge_tag edge_parallel_category; + typedef edge_list_graph_tag traversal_category; + typedef std::size_t edges_size_type; + typedef std::size_t vertices_size_type; + typedef std::size_t degree_size_type; + edge_list(EdgeIter first, EdgeIter last) : _first(first), _last(last) { + m_num_edges = std::distance(first, last); + } + edge_list(EdgeIter first, EdgeIter last, edges_size_type E) + : _first(first), _last(last), m_num_edges(E) { } + + EdgeIter _first, _last; + edges_size_type m_num_edges; + }; + + template + std::size_t num_edges(const edge_list& el) { + return el.m_num_edges; + } + +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + template + inline edge_list + make_edge_list(EdgeIter first, EdgeIter last) + { + return edge_list(first, last); + } +#endif + +} /* namespace boost */ + +#endif /* BOOST_GRAPH_EDGE_LIST_HPP */ diff --git a/deal.II/contrib/boost/include/boost/graph/edmunds_karp_max_flow.hpp b/deal.II/contrib/boost/include/boost/graph/edmunds_karp_max_flow.hpp new file mode 100644 index 0000000000..ddb49dc6d6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/edmunds_karp_max_flow.hpp @@ -0,0 +1,250 @@ +//======================================================================= +// Copyright 2000 University of Notre Dame. +// Authors: Jeremy G. Siek, Andrew Lumsdaine, Lie-Quan Lee +// +// 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 EDMUNDS_KARP_MAX_FLOW_HPP +#define EDMUNDS_KARP_MAX_FLOW_HPP + +#include +#include +#include // for std::min and std::max +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + // The "labeling" algorithm from "Network Flows" by Ahuja, Magnanti, + // Orlin. I think this is the same as or very similar to the original + // Edmunds-Karp algorithm. This solves the maximum flow problem. + + namespace detail { + + template + filtered_graph > + residual_graph(Graph& g, ResCapMap residual_capacity) { + return filtered_graph > + (g, is_residual_edge(residual_capacity)); + } + + template + inline void + augment(Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + PredEdgeMap p, + ResCapMap residual_capacity, + RevEdgeMap reverse_edge) + { + typename graph_traits::edge_descriptor e; + typename graph_traits::vertex_descriptor u; + typedef typename property_traits::value_type FlowValue; + + // find minimum residual capacity along the augmenting path + FlowValue delta = (std::numeric_limits::max)(); + e = p[sink]; + do { + BOOST_USING_STD_MIN(); + delta = min BOOST_PREVENT_MACRO_SUBSTITUTION(delta, residual_capacity[e]); + u = source(e, g); + e = p[u]; + } while (u != src); + + // push delta units of flow along the augmenting path + e = p[sink]; + do { + residual_capacity[e] -= delta; + residual_capacity[reverse_edge[e]] += delta; + u = source(e, g); + e = p[u]; + } while (u != src); + } + + } // namespace detail + + template + typename property_traits::value_type + edmunds_karp_max_flow + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + CapacityEdgeMap cap, + ResidualCapacityEdgeMap res, + ReverseEdgeMap rev, + ColorMap color, + PredEdgeMap pred) + { + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + typename graph_traits::vertex_iterator u_iter, u_end; + typename graph_traits::out_edge_iterator ei, e_end; + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) + for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei) + res[*ei] = cap[*ei]; + + color[sink] = Color::gray(); + while (color[sink] != Color::white()) { + boost::queue Q; + breadth_first_search + (detail::residual_graph(g, res), src, Q, + make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge())), + color); + if (color[sink] != Color::white()) + detail::augment(g, src, sink, pred, res, rev); + } // while + + typename property_traits::value_type flow = 0; + for (tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei) + flow += (cap[*ei] - res[*ei]); + return flow; + } // edmunds_karp_max_flow() + + namespace detail { + //------------------------------------------------------------------------- + // Handle default for color property map + + // use of class here is a VC++ workaround + template + struct edmunds_karp_dispatch2 { + template + static typename edge_capacity_value::type + apply + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + PredMap pred, + const bgl_named_params& params, + ColorMap color) + { + return edmunds_karp_max_flow + (g, src, sink, + choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity), + choose_pmap(get_param(params, edge_residual_capacity), + g, edge_residual_capacity), + choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse), + color, pred); + } + }; + template<> + struct edmunds_karp_dispatch2 { + template + static typename edge_capacity_value::type + apply + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + PredMap pred, + const bgl_named_params& params, + detail::error_property_not_found) + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename graph_traits::vertices_size_type size_type; + size_type n = is_default_param(get_param(params, vertex_color)) ? + num_vertices(g) : 1; + std::vector color_vec(n); + return edmunds_karp_max_flow + (g, src, sink, + choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity), + choose_pmap(get_param(params, edge_residual_capacity), + g, edge_residual_capacity), + choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse), + make_iterator_property_map(color_vec.begin(), choose_const_pmap + (get_param(params, vertex_index), + g, vertex_index), color_vec[0]), + pred); + } + }; + + //------------------------------------------------------------------------- + // Handle default for predecessor property map + + // use of class here is a VC++ workaround + template + struct edmunds_karp_dispatch1 { + template + static typename edge_capacity_value::type + apply(Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + const bgl_named_params& params, + PredMap pred) + { + typedef typename property_value< bgl_named_params, vertex_color_t>::type C; + return edmunds_karp_dispatch2::apply + (g, src, sink, pred, params, get_param(params, vertex_color)); + } + }; + template<> + struct edmunds_karp_dispatch1 { + + template + static typename edge_capacity_value::type + apply + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + const bgl_named_params& params, + detail::error_property_not_found) + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename graph_traits::vertices_size_type size_type; + size_type n = is_default_param(get_param(params, vertex_predecessor)) ? + num_vertices(g) : 1; + std::vector pred_vec(n); + + typedef typename property_value< bgl_named_params, vertex_color_t>::type C; + return edmunds_karp_dispatch2::apply + (g, src, sink, + make_iterator_property_map(pred_vec.begin(), choose_const_pmap + (get_param(params, vertex_index), + g, vertex_index), pred_vec[0]), + params, + get_param(params, vertex_color)); + } + }; + + } // namespace detail + + template + typename detail::edge_capacity_value::type + edmunds_karp_max_flow + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + const bgl_named_params& params) + { + typedef typename property_value< bgl_named_params, vertex_predecessor_t>::type Pred; + return detail::edmunds_karp_dispatch1::apply + (g, src, sink, params, get_param(params, vertex_predecessor)); + } + + template + typename property_traits< + typename property_map::const_type + >::value_type + edmunds_karp_max_flow + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink) + { + bgl_named_params params(0); + return edmunds_karp_max_flow(g, src, sink, params); + } + +} // namespace boost + +#endif // EDMUNDS_KARP_MAX_FLOW_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/erdos_renyi_generator.hpp b/deal.II/contrib/boost/include/boost/graph/erdos_renyi_generator.hpp new file mode 100644 index 0000000000..7d2250705f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/erdos_renyi_generator.hpp @@ -0,0 +1,93 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_ERDOS_RENYI_GENERATOR_HPP +#define BOOST_GRAPH_ERDOS_RENYI_GENERATOR_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + class erdos_renyi_iterator + { + typedef typename graph_traits::directed_category directed_category; + typedef typename graph_traits::vertices_size_type vertices_size_type; + typedef typename graph_traits::edges_size_type edges_size_type; + + BOOST_STATIC_CONSTANT + (bool, + is_undirected = (is_base_and_derived::value + || is_same::value)); + + public: + typedef std::input_iterator_tag iterator_category; + typedef std::pair value_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef void difference_type; + + erdos_renyi_iterator() : gen(0), n(0), edges(0), allow_self_loops(false) {} + erdos_renyi_iterator(RandomGenerator& gen, vertices_size_type n, + double prob = 0.0, bool allow_self_loops = false) + : gen(&gen), n(n), edges(edges_size_type(prob * n * n)), + allow_self_loops(allow_self_loops) + { + if (is_undirected) edges = edges / 2; + next(); + } + + reference operator*() const { return current; } + pointer operator->() const { return ¤t; } + + erdos_renyi_iterator& operator++() + { + --edges; + next(); + return *this; + } + + erdos_renyi_iterator operator++(int) + { + erdos_renyi_iterator temp(*this); + ++(*this); + return temp; + } + + bool operator==(const erdos_renyi_iterator& other) const + { return edges == other.edges; } + + bool operator!=(const erdos_renyi_iterator& other) const + { return !(*this == other); } + + private: + void next() + { + uniform_int rand_vertex(0, n-1); + current.first = rand_vertex(*gen); + do { + current.second = rand_vertex(*gen); + } while (current.first == current.second && !allow_self_loops); + } + + RandomGenerator* gen; + vertices_size_type n; + edges_size_type edges; + bool allow_self_loops; + value_type current; + }; + +} // end namespace boost + +#endif // BOOST_GRAPH_ERDOS_RENYI_GENERATOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/exception.hpp b/deal.II/contrib/boost/include/boost/graph/exception.hpp new file mode 100644 index 0000000000..09c82edc3c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/exception.hpp @@ -0,0 +1,44 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_EXCEPTION_HPP +#define BOOST_GRAPH_EXCEPTION_HPP + +#include +#include + +namespace boost { + + struct bad_graph : public std::invalid_argument { + bad_graph(const std::string& what_arg) + : std::invalid_argument(what_arg) { } + }; + + struct not_a_dag : public bad_graph { + not_a_dag() + : bad_graph("The graph must be a DAG.") { } + }; + + struct negative_edge : public bad_graph { + negative_edge() + : bad_graph("The graph may not contain an edge with negative weight."){ } + }; + + struct negative_cycle : public bad_graph { + negative_cycle() + : bad_graph("The graph may not contain negative cycles.") { } + }; + struct not_connected : public bad_graph { + not_connected() + : bad_graph("The graph must be connected.") { } + }; + +} // namespace boost + +#endif // BOOST_GRAPH_EXCEPTION_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/filtered_graph.hpp b/deal.II/contrib/boost/include/boost/graph/filtered_graph.hpp new file mode 100644 index 0000000000..389ea21e2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/filtered_graph.hpp @@ -0,0 +1,491 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_FILTERED_GRAPH_HPP +#define BOOST_FILTERED_GRAPH_HPP + +#include +#include +#include +#include + +namespace boost { + + //========================================================================= + // Some predicate classes. + + struct keep_all { + template + bool operator()(const T&) const { return true; } + }; + + // Keep residual edges (used in maximum-flow algorithms). + template + struct is_residual_edge { + is_residual_edge() { } + is_residual_edge(ResidualCapacityEdgeMap rcap) : m_rcap(rcap) { } + template + bool operator()(const Edge& e) const { + return 0 < get(m_rcap, e); + } + ResidualCapacityEdgeMap m_rcap; + }; + + template + struct is_in_subset { + is_in_subset() : m_s(0) { } + is_in_subset(const Set& s) : m_s(&s) { } + + template + bool operator()(const Elt& x) const { + return set_contains(*m_s, x); + } + const Set* m_s; + }; + + template + struct is_not_in_subset { + is_not_in_subset() : m_s(0) { } + is_not_in_subset(const Set& s) : m_s(&s) { } + + template + bool operator()(const Elt& x) const { + return !set_contains(*m_s, x); + } + const Set* m_s; + }; + + namespace detail { + + template + struct out_edge_predicate { + out_edge_predicate() { } + out_edge_predicate(EdgePredicate ep, VertexPredicate vp, + const Graph& g) + : m_edge_pred(ep), m_vertex_pred(vp), m_g(&g) { } + + template + bool operator()(const Edge& e) const { + return m_edge_pred(e) && m_vertex_pred(target(e, *m_g)); + } + EdgePredicate m_edge_pred; + VertexPredicate m_vertex_pred; + const Graph* m_g; + }; + + template + struct in_edge_predicate { + in_edge_predicate() { } + in_edge_predicate(EdgePredicate ep, VertexPredicate vp, + const Graph& g) + : m_edge_pred(ep), m_vertex_pred(vp), m_g(&g) { } + + template + bool operator()(const Edge& e) const { + return m_edge_pred(e) && m_vertex_pred(source(e, *m_g)); + } + EdgePredicate m_edge_pred; + VertexPredicate m_vertex_pred; + const Graph* m_g; + }; + + template + struct edge_predicate { + edge_predicate() { } + edge_predicate(EdgePredicate ep, VertexPredicate vp, + const Graph& g) + : m_edge_pred(ep), m_vertex_pred(vp), m_g(&g) { } + + template + bool operator()(const Edge& e) const { + return m_edge_pred(e) + && m_vertex_pred(source(e, *m_g)) && m_vertex_pred(target(e, *m_g)); + } + EdgePredicate m_edge_pred; + VertexPredicate m_vertex_pred; + const Graph* m_g; + }; + + } // namespace detail + + + //=========================================================================== + // Filtered Graph + + struct filtered_graph_tag { }; + + // This base class is a stupid hack to change overload resolution + // rules for the source and target functions so that they are a + // worse match than the source and target functions defined for + // pairs in graph_traits.hpp. I feel dirty. -JGS + template + struct filtered_graph_base { + typedef graph_traits Traits; + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + filtered_graph_base(const G& g) : m_g(g) { } + //protected: + const G& m_g; + }; + + template + class filtered_graph : public filtered_graph_base { + typedef filtered_graph_base Base; + typedef graph_traits Traits; + typedef filtered_graph self; + public: + typedef Graph graph_type; + typedef detail::out_edge_predicate OutEdgePred; + typedef detail::in_edge_predicate InEdgePred; + typedef detail::edge_predicate EdgePred; + + // Constructors + filtered_graph(const Graph& g, EdgePredicate ep) + : Base(g), m_edge_pred(ep) { } + + filtered_graph(const Graph& g, EdgePredicate ep, VertexPredicate vp) + : Base(g), m_edge_pred(ep), m_vertex_pred(vp) { } + + // Graph requirements + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + typedef typename Traits::directed_category directed_category; + typedef typename Traits::edge_parallel_category edge_parallel_category; + typedef typename Traits::traversal_category traversal_category; + + // IncidenceGraph requirements + typedef filter_iterator< + OutEdgePred, typename Traits::out_edge_iterator + > out_edge_iterator; + + typedef typename Traits::degree_size_type degree_size_type; + + // AdjacencyGraph requirements + typedef typename adjacency_iterator_generator::type adjacency_iterator; + + // BidirectionalGraph requirements + typedef filter_iterator< + InEdgePred, typename Traits::in_edge_iterator + > in_edge_iterator; + + // VertexListGraph requirements + typedef filter_iterator< + VertexPredicate, typename Traits::vertex_iterator + > vertex_iterator; + typedef typename Traits::vertices_size_type vertices_size_type; + + // EdgeListGraph requirements + typedef filter_iterator< + EdgePred, typename Traits::edge_iterator + > edge_iterator; + typedef typename Traits::edges_size_type edges_size_type; + + typedef typename ::boost::edge_property_type::type edge_property_type; + typedef typename ::boost::vertex_property_type::type vertex_property_type; + typedef filtered_graph_tag graph_tag; + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + // Bundled properties support + template + typename graph::detail::bundled_result::type& + operator[](Descriptor x) + { return const_cast(this->m_g)[x]; } + + template + typename graph::detail::bundled_result::type const& + operator[](Descriptor x) const + { return this->m_g[x]; } +#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES + + //private: + EdgePredicate m_edge_pred; + VertexPredicate m_vertex_pred; + }; + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + template + struct vertex_bundle_type > + : vertex_bundle_type { }; + + template + struct edge_bundle_type > + : edge_bundle_type { }; +#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES + + //=========================================================================== + // Non-member functions for the Filtered Edge Graph + + // Helper functions + template + inline filtered_graph + make_filtered_graph(Graph& g, EdgePredicate ep) { + return filtered_graph(g, ep); + } + template + inline filtered_graph + make_filtered_graph(Graph& g, EdgePredicate ep, VertexPredicate vp) { + return filtered_graph(g, ep, vp); + } + + template + std::pair::vertex_iterator, + typename filtered_graph::vertex_iterator> + vertices(const filtered_graph& g) + { + typedef filtered_graph Graph; + typename graph_traits::vertex_iterator f, l; + tie(f, l) = vertices(g.m_g); + typedef typename Graph::vertex_iterator iter; + return std::make_pair(iter(g.m_vertex_pred, f, l), + iter(g.m_vertex_pred, l, l)); + } + + template + std::pair::edge_iterator, + typename filtered_graph::edge_iterator> + edges(const filtered_graph& g) + { + typedef filtered_graph Graph; + typename Graph::EdgePred pred(g.m_edge_pred, g.m_vertex_pred, g); + typename graph_traits::edge_iterator f, l; + tie(f, l) = edges(g.m_g); + typedef typename Graph::edge_iterator iter; + return std::make_pair(iter(pred, f, l), iter(pred, l, l)); + } + + // An alternative for num_vertices() and num_edges() would be to + // count the number in the filtered graph. This is problematic + // because of the interaction with the vertex indices... they would + // no longer go from 0 to num_vertices(), which would cause trouble + // for algorithms allocating property storage in an array. We could + // try to create a mapping to new recalibrated indices, but I don't + // see an efficient way to do this. + // + // However, the current solution is still unsatisfactory because + // the following semantic constraints no longer hold: + // tie(vi, viend) = vertices(g); + // assert(std::distance(vi, viend) == num_vertices(g)); + + template + typename filtered_graph::vertices_size_type + num_vertices(const filtered_graph& g) { + return num_vertices(g.m_g); + } + + template + typename filtered_graph::edges_size_type + num_edges(const filtered_graph& g) { + return num_edges(g.m_g); + } + + template + typename filtered_graph_base::vertex_descriptor + source(typename filtered_graph_base::edge_descriptor e, + const filtered_graph_base& g) + { + return source(e, g.m_g); + } + + template + typename filtered_graph_base::vertex_descriptor + target(typename filtered_graph_base::edge_descriptor e, + const filtered_graph_base& g) + { + return target(e, g.m_g); + } + + template + std::pair::out_edge_iterator, + typename filtered_graph::out_edge_iterator> + out_edges(typename filtered_graph::vertex_descriptor u, + const filtered_graph& g) + { + typedef filtered_graph Graph; + typename Graph::OutEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g); + typedef typename Graph::out_edge_iterator iter; + typename graph_traits::out_edge_iterator f, l; + tie(f, l) = out_edges(u, g.m_g); + return std::make_pair(iter(pred, f, l), iter(pred, l, l)); + } + + template + typename filtered_graph::degree_size_type + out_degree(typename filtered_graph::vertex_descriptor u, + const filtered_graph& g) + { + typename filtered_graph::degree_size_type n = 0; + typename filtered_graph::out_edge_iterator f, l; + for (tie(f, l) = out_edges(u, g); f != l; ++f) + ++n; + return n; + } + + template + std::pair::adjacency_iterator, + typename filtered_graph::adjacency_iterator> + adjacent_vertices(typename filtered_graph::vertex_descriptor u, + const filtered_graph& g) + { + typedef filtered_graph Graph; + typedef typename Graph::adjacency_iterator adjacency_iterator; + typename Graph::out_edge_iterator f, l; + tie(f, l) = out_edges(u, g); + return std::make_pair(adjacency_iterator(f, const_cast(&g)), + adjacency_iterator(l, const_cast(&g))); + } + + template + std::pair::in_edge_iterator, + typename filtered_graph::in_edge_iterator> + in_edges(typename filtered_graph::vertex_descriptor u, + const filtered_graph& g) + { + typedef filtered_graph Graph; + typename Graph::InEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g); + typedef typename Graph::in_edge_iterator iter; + typename graph_traits::in_edge_iterator f, l; + tie(f, l) = in_edges(u, g.m_g); + return std::make_pair(iter(pred, f, l), iter(pred, l, l)); + } + + template + typename filtered_graph::degree_size_type + in_degree(typename filtered_graph::vertex_descriptor u, + const filtered_graph& g) + { + typename filtered_graph::degree_size_type n = 0; + typename filtered_graph::in_edge_iterator f, l; + for (tie(f, l) = in_edges(u, g); f != l; ++f) + ++n; + return n; + } + + template + std::pair::edge_descriptor, bool> + edge(typename filtered_graph::vertex_descriptor u, + typename filtered_graph::vertex_descriptor v, + const filtered_graph& g) + { + typename graph_traits::edge_descriptor e; + bool exists; + tie(e, exists) = edge(u, v, g.m_g); + return std::make_pair(e, exists && g.m_edge_pred(e)); + } + + template + std::pair::out_edge_iterator, + typename filtered_graph::out_edge_iterator> + edge_range(typename filtered_graph::vertex_descriptor u, + typename filtered_graph::vertex_descriptor v, + const filtered_graph& g) + { + typedef filtered_graph Graph; + typename Graph::OutEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g); + typedef typename Graph::out_edge_iterator iter; + typename graph_traits::out_edge_iterator f, l; + tie(f, l) = edge_range(u, v, g.m_g); + return std::make_pair(iter(pred, f, l), iter(pred, l, l)); + } + + + //=========================================================================== + // Property map + + namespace detail { + struct filtered_graph_property_selector { + template + struct bind_ { + typedef typename FilteredGraph::graph_type Graph; + typedef property_map Map; + typedef typename Map::type type; + typedef typename Map::const_type const_type; + }; + }; + } // namespace detail + + template <> + struct vertex_property_selector { + typedef detail::filtered_graph_property_selector type; + }; + template <> + struct edge_property_selector { + typedef detail::filtered_graph_property_selector type; + }; + + template + typename property_map::type + get(Property p, filtered_graph& g) + { + return get(p, const_cast(g.m_g)); + } + + template + typename property_map::const_type + get(Property p, const filtered_graph& g) + { + return get(p, (const G&)g.m_g); + } + + template + typename property_map_value::type + get(Property p, const filtered_graph& g, const Key& k) + { + return get(p, (const G&)g.m_g, k); + } + + template + void + put(Property p, const filtered_graph& g, const Key& k, + const Value& val) + { + put(p, const_cast(g.m_g), k, val); + } + + //=========================================================================== + // Some filtered subgraph specializations + + template + struct vertex_subset_filter { + typedef filtered_graph > type; + }; + template + inline typename vertex_subset_filter::type + make_vertex_subset_filter(Graph& g, const Set& s) { + typedef typename vertex_subset_filter::type Filter; + is_in_subset p(s); + return Filter(g, keep_all(), p); + } + + template + struct vertex_subset_compliment_filter { + typedef filtered_graph > type; + }; + template + inline typename vertex_subset_compliment_filter::type + make_vertex_subset_compliment_filter(Graph& g, const Set& s) { + typedef typename vertex_subset_compliment_filter::type Filter; + is_not_in_subset p(s); + return Filter(g, keep_all(), p); + } + + +} // namespace boost + + +#endif // BOOST_FILTERED_GRAPH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/floyd_warshall_shortest.hpp b/deal.II/contrib/boost/include/boost/graph/floyd_warshall_shortest.hpp new file mode 100644 index 0000000000..a45aed90d8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/floyd_warshall_shortest.hpp @@ -0,0 +1,243 @@ +// Copyright 2002 Rensselaer Polytechnic Institute + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Lauren Foutz +// Scott Hill + +/* + This file implements the functions + + template + bool floyd_warshall_initialized_all_pairs_shortest_paths( + const VertexListGraph& g, DistanceMatrix& d, + const bgl_named_params& params) + + AND + + template + bool floyd_warshall_all_pairs_shortest_paths( + const VertexAndEdgeListGraph& g, DistanceMatrix& d, + const bgl_named_params& params) +*/ + + +#ifndef BOOST_GRAPH_FLOYD_WARSHALL_HPP +#define BOOST_GRAPH_FLOYD_WARSHALL_HPP + +#include +#include +#include +#include +#include +#include // for std::min and std::max + +namespace boost +{ + namespace detail { + template + bool floyd_warshall_dispatch(const VertexListGraph& g, + DistanceMatrix& d, const BinaryPredicate &compare, + const BinaryFunction &combine, const Infinity& inf, + const Zero& zero) + { + BOOST_USING_STD_MIN(); + + typename graph_traits::vertex_iterator + i, lasti, j, lastj, k, lastk; + + + for (tie(k, lastk) = vertices(g); k != lastk; k++) + for (tie(i, lasti) = vertices(g); i != lasti; i++) + for (tie(j, lastj) = vertices(g); j != lastj; j++) + { + d[*i][*j] = min BOOST_PREVENT_MACRO_SUBSTITUTION + (d[*i][*j], combine(d[*i][*k], d[*k][*j])); + } + + + for (tie(i, lasti) = vertices(g); i != lasti; i++) + if (compare(d[*i][*i], zero)) + return false; + return true; + } + } + + template + bool floyd_warshall_initialized_all_pairs_shortest_paths( + const VertexListGraph& g, DistanceMatrix& d, + const BinaryPredicate& compare, + const BinaryFunction& combine, const Infinity& inf, + const Zero& zero) + { + function_requires >(); + + return detail::floyd_warshall_dispatch(g, d, compare, combine, + inf, zero); + } + + + + template + bool floyd_warshall_all_pairs_shortest_paths( + const VertexAndEdgeListGraph& g, + DistanceMatrix& d, const WeightMap& w, + const BinaryPredicate& compare, const BinaryFunction& combine, + const Infinity& inf, const Zero& zero) + { + BOOST_USING_STD_MIN(); + + function_requires >(); + function_requires >(); + function_requires >(); + + typename graph_traits::vertex_iterator + firstv, lastv, firstv2, lastv2; + typename graph_traits::edge_iterator first, last; + + + for(tie(firstv, lastv) = vertices(g); firstv != lastv; firstv++) + for(tie(firstv2, lastv2) = vertices(g); firstv2 != lastv2; firstv2++) + d[*firstv][*firstv2] = inf; + + + for(tie(firstv, lastv) = vertices(g); firstv != lastv; firstv++) + d[*firstv][*firstv] = 0; + + + for(tie(first, last) = edges(g); first != last; first++) + { + if (d[source(*first, g)][target(*first, g)] != inf) + d[source(*first, g)][target(*first, g)] = + min BOOST_PREVENT_MACRO_SUBSTITUTION(get(w, *first), + d[source(*first, g)][target(*first, g)]); + else + d[source(*first, g)][target(*first, g)] = get(w, *first); + } + + bool is_undirected = is_same::directed_category, + undirected_tag>::value; + if (is_undirected) + { + for(tie(first, last) = edges(g); first != last; first++) + { + if (d[target(*first, g)][source(*first, g)] != inf) + d[target(*first, g)][source(*first, g)] = + min BOOST_PREVENT_MACRO_SUBSTITUTION(get(w, *first), + d[target(*first, g)][source(*first, g)]); + else + d[target(*first, g)][source(*first, g)] = get(w, *first); + } + } + + + return detail::floyd_warshall_dispatch(g, d, compare, combine, + inf, zero); + } + + + namespace detail { + template + bool floyd_warshall_init_dispatch(const VertexListGraph& g, + DistanceMatrix& d, WeightMap w, + const bgl_named_params& params) + { + typedef typename property_traits::value_type WM; + + return floyd_warshall_initialized_all_pairs_shortest_paths(g, d, + choose_param(get_param(params, distance_compare_t()), + std::less()), + choose_param(get_param(params, distance_combine_t()), + closed_plus()), + choose_param(get_param(params, distance_inf_t()), + std::numeric_limits::max BOOST_PREVENT_MACRO_SUBSTITUTION()), + choose_param(get_param(params, distance_zero_t()), + WM())); + } + + + + template + bool floyd_warshall_noninit_dispatch(const VertexAndEdgeListGraph& g, + DistanceMatrix& d, WeightMap w, + const bgl_named_params& params) + { + typedef typename property_traits::value_type WM; + + return floyd_warshall_all_pairs_shortest_paths(g, d, w, + choose_param(get_param(params, distance_compare_t()), + std::less()), + choose_param(get_param(params, distance_combine_t()), + closed_plus()), + choose_param(get_param(params, distance_inf_t()), + std::numeric_limits::max BOOST_PREVENT_MACRO_SUBSTITUTION()), + choose_param(get_param(params, distance_zero_t()), + WM())); + } + + + } // namespace detail + + + + template + bool floyd_warshall_initialized_all_pairs_shortest_paths( + const VertexListGraph& g, DistanceMatrix& d, + const bgl_named_params& params) + { + return detail::floyd_warshall_init_dispatch(g, d, + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + params); + } + + template + bool floyd_warshall_initialized_all_pairs_shortest_paths( + const VertexListGraph& g, DistanceMatrix& d) + { + bgl_named_params params(0); + return detail::floyd_warshall_init_dispatch(g, d, + get(edge_weight, g), params); + } + + + + + template + bool floyd_warshall_all_pairs_shortest_paths( + const VertexAndEdgeListGraph& g, DistanceMatrix& d, + const bgl_named_params& params) + { + return detail::floyd_warshall_noninit_dispatch(g, d, + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + params); + } + + template + bool floyd_warshall_all_pairs_shortest_paths( + const VertexAndEdgeListGraph& g, DistanceMatrix& d) + { + bgl_named_params params(0); + return detail::floyd_warshall_noninit_dispatch(g, d, + get(edge_weight, g), params); + } + + +} // namespace boost + +#endif + diff --git a/deal.II/contrib/boost/include/boost/graph/fruchterman_reingold.hpp b/deal.II/contrib/boost/include/boost/graph/fruchterman_reingold.hpp new file mode 100644 index 0000000000..df0208928d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/fruchterman_reingold.hpp @@ -0,0 +1,420 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_FRUCHTERMAN_REINGOLD_FORCE_DIRECTED_LAYOUT_HPP +#define BOOST_GRAPH_FRUCHTERMAN_REINGOLD_FORCE_DIRECTED_LAYOUT_HPP + +#include +#include +#include +#include +#include +#include +#include // for std::min and std::max + +namespace boost { + +struct square_distance_attractive_force { + template + T + operator()(typename graph_traits::edge_descriptor, + T k, + T d, + const Graph&) const + { + return d * d / k; + } +}; + +struct square_distance_repulsive_force { + template + T + operator()(typename graph_traits::vertex_descriptor, + typename graph_traits::vertex_descriptor, + T k, + T d, + const Graph&) const + { + return k * k / d; + } +}; + +template +struct linear_cooling { + typedef T result_type; + + linear_cooling(std::size_t iterations) + : temp(T(iterations) / T(10)), step(0.1) { } + + linear_cooling(std::size_t iterations, T temp) + : temp(temp), step(temp / T(iterations)) { } + + T operator()() + { + T old_temp = temp; + temp -= step; + if (temp < T(0)) temp = T(0); + return old_temp; + } + + private: + T temp; + T step; +}; + +struct all_force_pairs +{ + template + void operator()(const Graph& g, ApplyForce apply_force) + { + typedef typename graph_traits::vertex_iterator vertex_iterator; + vertex_iterator v, end; + for (tie(v, end) = vertices(g); v != end; ++v) { + vertex_iterator u = v; + for (++u; u != end; ++u) { + apply_force(*u, *v); + apply_force(*v, *u); + } + } + } +}; + +template +struct grid_force_pairs +{ + template + explicit + grid_force_pairs(Dim width, Dim height, PositionMap position, const Graph& g) + : width(width), height(height), position(position) + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif // BOOST_NO_STDC_NAMESPACE + two_k = Dim(2) * sqrt(width*height / num_vertices(g)); + } + + template + void operator()(const Graph& g, ApplyForce apply_force) + { + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef std::list bucket_t; + typedef std::vector buckets_t; + + std::size_t columns = std::size_t(width / two_k + Dim(1)); + std::size_t rows = std::size_t(height / two_k + Dim(1)); + buckets_t buckets(rows * columns); + vertex_iterator v, v_end; + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + std::size_t column = std::size_t((position[*v].x + width / 2) / two_k); + std::size_t row = std::size_t((position[*v].y + height / 2) / two_k); + + if (column >= columns) column = columns - 1; + if (row >= rows) row = rows - 1; + buckets[row * columns + column].push_back(*v); + } + + for (std::size_t row = 0; row < rows; ++row) + for (std::size_t column = 0; column < columns; ++column) { + bucket_t& bucket = buckets[row * columns + column]; + typedef typename bucket_t::iterator bucket_iterator; + for (bucket_iterator u = bucket.begin(); u != bucket.end(); ++u) { + // Repulse vertices in this bucket + bucket_iterator v = u; + for (++v; v != bucket.end(); ++v) { + apply_force(*u, *v); + apply_force(*v, *u); + } + + std::size_t adj_start_row = row == 0? 0 : row - 1; + std::size_t adj_end_row = row == rows - 1? row : row + 1; + std::size_t adj_start_column = column == 0? 0 : column - 1; + std::size_t adj_end_column = column == columns - 1? column : column + 1; + for (std::size_t other_row = adj_start_row; other_row <= adj_end_row; + ++other_row) + for (std::size_t other_column = adj_start_column; + other_column <= adj_end_column; ++other_column) + if (other_row != row || other_column != column) { + // Repulse vertices in this bucket + bucket_t& other_bucket + = buckets[other_row * columns + other_column]; + for (v = other_bucket.begin(); v != other_bucket.end(); ++v) + apply_force(*u, *v); + } + } + } + } + + private: + Dim width; + Dim height; + PositionMap position; + Dim two_k; +}; + +template +inline grid_force_pairs +make_grid_force_pairs(Dim width, Dim height, const PositionMap& position, + const Graph& g) +{ return grid_force_pairs(width, height, position, g); } + +template +void +scale_graph(const Graph& g, PositionMap position, + Dim left, Dim top, Dim right, Dim bottom) +{ + if (num_vertices(g) == 0) return; + + if (bottom > top) { + using std::swap; + swap(bottom, top); + } + + typedef typename graph_traits::vertex_iterator vertex_iterator; + + // Find min/max ranges + Dim minX = position[*vertices(g).first].x, maxX = minX; + Dim minY = position[*vertices(g).first].y, maxY = minY; + vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) { + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + minX = min BOOST_PREVENT_MACRO_SUBSTITUTION (minX, position[*vi].x); + maxX = max BOOST_PREVENT_MACRO_SUBSTITUTION (maxX, position[*vi].x); + minY = min BOOST_PREVENT_MACRO_SUBSTITUTION (minY, position[*vi].y); + maxY = max BOOST_PREVENT_MACRO_SUBSTITUTION (maxY, position[*vi].y); + } + + // Scale to bounding box provided + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) { + position[*vi].x = ((position[*vi].x - minX) / (maxX - minX)) + * (right - left) + left; + position[*vi].y = ((position[*vi].y - minY) / (maxY - minY)) + * (top - bottom) + bottom; + } +} + +namespace detail { + template + struct fr_apply_force + { + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + + fr_apply_force(const PositionMap& position, + const DisplacementMap& displacement, + RepulsiveForce repulsive_force, Dim k, const Graph& g) + : position(position), displacement(displacement), + repulsive_force(repulsive_force), k(k), g(g) + { } + + void operator()(vertex_descriptor u, vertex_descriptor v) + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif // BOOST_NO_STDC_NAMESPACE + if (u != v) { + Dim delta_x = position[v].x - position[u].x; + Dim delta_y = position[v].y - position[u].y; + Dim dist = sqrt(delta_x * delta_x + delta_y * delta_y); + Dim fr = repulsive_force(u, v, k, dist, g); + displacement[v].x += delta_x / dist * fr; + displacement[v].y += delta_y / dist * fr; + } + } + + private: + PositionMap position; + DisplacementMap displacement; + RepulsiveForce repulsive_force; + Dim k; + const Graph& g; + }; + +} // end namespace detail + +template +void +fruchterman_reingold_force_directed_layout + (const Graph& g, + PositionMap position, + Dim width, + Dim height, + AttractiveForce attractive_force, + RepulsiveForce repulsive_force, + ForcePairs force_pairs, + Cooling cool, + DisplacementMap displacement) +{ + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef typename graph_traits::edge_iterator edge_iterator; + +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif // BOOST_NO_STDC_NAMESPACE + + Dim area = width * height; + // assume positions are initialized randomly + Dim k = sqrt(area / num_vertices(g)); + + detail::fr_apply_force + apply_force(position, displacement, repulsive_force, k, g); + + Dim temp = cool(); + if (temp) do { + // Calculate repulsive forces + vertex_iterator v, v_end; + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + displacement[*v].x = 0; + displacement[*v].y = 0; + } + force_pairs(g, apply_force); + + // Calculate attractive forces + edge_iterator e, e_end; + for (tie(e, e_end) = edges(g); e != e_end; ++e) { + vertex_descriptor v = source(*e, g); + vertex_descriptor u = target(*e, g); + Dim delta_x = position[v].x - position[u].x; + Dim delta_y = position[v].y - position[u].y; + Dim dist = sqrt(delta_x * delta_x + delta_y * delta_y); + Dim fa = attractive_force(*e, k, dist, g); + + displacement[v].x -= delta_x / dist * fa; + displacement[v].y -= delta_y / dist * fa; + displacement[u].x += delta_x / dist * fa; + displacement[u].y += delta_y / dist * fa; + } + + // Update positions + for (tie(v, v_end) = vertices(g); v != v_end; ++v) { + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + Dim disp_size = sqrt(displacement[*v].x * displacement[*v].x + + displacement[*v].y * displacement[*v].y); + position[*v].x += displacement[*v].x / disp_size + * min BOOST_PREVENT_MACRO_SUBSTITUTION (disp_size, temp); + position[*v].y += displacement[*v].y / disp_size + * min BOOST_PREVENT_MACRO_SUBSTITUTION (disp_size, temp); + position[*v].x = min BOOST_PREVENT_MACRO_SUBSTITUTION + (width / 2, + max BOOST_PREVENT_MACRO_SUBSTITUTION(-width / 2, + position[*v].x)); + position[*v].y = min BOOST_PREVENT_MACRO_SUBSTITUTION + (height / 2, + max BOOST_PREVENT_MACRO_SUBSTITUTION(-height / 2, + position[*v].y)); + } + } while (temp = cool()); +} + +namespace detail { + template + struct fr_force_directed_layout + { + template + static void + run(const Graph& g, + PositionMap position, + Dim width, + Dim height, + AttractiveForce attractive_force, + RepulsiveForce repulsive_force, + ForcePairs force_pairs, + Cooling cool, + DisplacementMap displacement, + const bgl_named_params&) + { + fruchterman_reingold_force_directed_layout + (g, position, width, height, attractive_force, repulsive_force, + force_pairs, cool, displacement); + } + }; + + template<> + struct fr_force_directed_layout + { + template + static void + run(const Graph& g, + PositionMap position, + Dim width, + Dim height, + AttractiveForce attractive_force, + RepulsiveForce repulsive_force, + ForcePairs force_pairs, + Cooling cool, + error_property_not_found, + const bgl_named_params& params) + { + std::vector > displacements(num_vertices(g)); + fruchterman_reingold_force_directed_layout + (g, position, width, height, attractive_force, repulsive_force, + force_pairs, cool, + make_iterator_property_map + (displacements.begin(), + choose_const_pmap(get_param(params, vertex_index), g, + vertex_index), + simple_point())); + } + }; + +} // end namespace detail + +template +void +fruchterman_reingold_force_directed_layout + (const Graph& g, + PositionMap position, + Dim width, + Dim height, + const bgl_named_params& params) +{ + typedef typename property_value, + vertex_displacement_t>::type D; + + detail::fr_force_directed_layout::run + (g, position, width, height, + choose_param(get_param(params, attractive_force_t()), + square_distance_attractive_force()), + choose_param(get_param(params, repulsive_force_t()), + square_distance_repulsive_force()), + choose_param(get_param(params, force_pairs_t()), + make_grid_force_pairs(width, height, position, g)), + choose_param(get_param(params, cooling_t()), + linear_cooling(100)), + get_param(params, vertex_displacement_t()), + params); +} + +template +void +fruchterman_reingold_force_directed_layout(const Graph& g, + PositionMap position, + Dim width, + Dim height) +{ + fruchterman_reingold_force_directed_layout + (g, position, width, height, + attractive_force(square_distance_attractive_force())); +} + +} // end namespace boost + +#endif // BOOST_GRAPH_FRUCHTERMAN_REINGOLD_FORCE_DIRECTED_LAYOUT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/graph_archetypes.hpp b/deal.II/contrib/boost/include/boost/graph/graph_archetypes.hpp new file mode 100644 index 0000000000..ce4c85fd08 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_archetypes.hpp @@ -0,0 +1,290 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_ARCHETYPES_HPP +#define BOOST_GRAPH_ARCHETYPES_HPP + +#include +#include + +namespace boost { // should use a different namespace for this + + namespace detail { + struct null_graph_archetype : public null_archetype<> { + struct traversal_category { }; + }; + } + + //=========================================================================== + template + struct incidence_graph_archetype : public Base + { + typedef typename Base::traversal_category base_trav_cat; + struct traversal_category + : public incidence_graph_tag, public base_trav_cat { }; +#if 0 + typedef immutable_graph_tag mutability_category; +#endif + typedef Vertex vertex_descriptor; + typedef unsigned int degree_size_type; + typedef unsigned int vertices_size_type; + typedef unsigned int edges_size_type; + struct edge_descriptor { + edge_descriptor() { } + edge_descriptor(const detail::dummy_constructor&) { } + bool operator==(const edge_descriptor&) const { return false; } + bool operator!=(const edge_descriptor&) const { return false; } + }; + typedef input_iterator_archetype out_edge_iterator; + + typedef Directed directed_category; + typedef ParallelCategory edge_parallel_category; + + typedef void adjacency_iterator; + typedef void in_edge_iterator; + typedef void vertex_iterator; + typedef void edge_iterator; + }; + template + V source(const typename incidence_graph_archetype::edge_descriptor&, + const incidence_graph_archetype& ) + { + return V(static_object::get()); + } + template + V target(const typename incidence_graph_archetype::edge_descriptor&, + const incidence_graph_archetype& ) + { + return V(static_object::get()); + } + + template + std::pair::out_edge_iterator, + typename incidence_graph_archetype::out_edge_iterator> + out_edges(const V&, const incidence_graph_archetype& ) + { + typedef typename incidence_graph_archetype::out_edge_iterator Iter; + return std::make_pair(Iter(), Iter()); + } + + template + typename incidence_graph_archetype::degree_size_type + out_degree(const V&, const incidence_graph_archetype& ) + { + return 0; + } + + //=========================================================================== + template + struct adjacency_graph_archetype : public Base + { + typedef typename Base::traversal_category base_trav_cat; + struct traversal_category + : public adjacency_graph_tag, public base_trav_cat { }; + typedef Vertex vertex_descriptor; + typedef unsigned int degree_size_type; + typedef unsigned int vertices_size_type; + typedef unsigned int edges_size_type; + typedef void edge_descriptor; + typedef input_iterator_archetype adjacency_iterator; + + typedef Directed directed_category; + typedef ParallelCategory edge_parallel_category; + + typedef void in_edge_iterator; + typedef void out_edge_iterator; + typedef void vertex_iterator; + typedef void edge_iterator; + }; + + template + std::pair::adjacency_iterator, + typename adjacency_graph_archetype::adjacency_iterator> + adjacent_vertices(const V&, const adjacency_graph_archetype& ) + { + typedef typename adjacency_graph_archetype::adjacency_iterator Iter; + return std::make_pair(Iter(), Iter()); + } + + template + typename adjacency_graph_archetype::degree_size_type + out_degree(const V&, const adjacency_graph_archetype& ) + { + return 0; + } + + //=========================================================================== + template + struct vertex_list_graph_archetype : public Base + { + typedef incidence_graph_archetype + Incidence; + typedef adjacency_graph_archetype + Adjacency; + + typedef typename Base::traversal_category base_trav_cat; + struct traversal_category + : public vertex_list_graph_tag, public base_trav_cat { }; +#if 0 + typedef immutable_graph_tag mutability_category; +#endif + typedef Vertex vertex_descriptor; + typedef unsigned int degree_size_type; + typedef typename Incidence::edge_descriptor edge_descriptor; + typedef typename Incidence::out_edge_iterator out_edge_iterator; + typedef typename Adjacency::adjacency_iterator adjacency_iterator; + + typedef input_iterator_archetype vertex_iterator; + typedef unsigned int vertices_size_type; + typedef unsigned int edges_size_type; + + typedef Directed directed_category; + typedef ParallelCategory edge_parallel_category; + + typedef void in_edge_iterator; + typedef void edge_iterator; + }; + + template + std::pair::vertex_iterator, + typename vertex_list_graph_archetype::vertex_iterator> + vertices(const vertex_list_graph_archetype& ) + { + typedef typename vertex_list_graph_archetype::vertex_iterator Iter; + return std::make_pair(Iter(), Iter()); + } + + template + typename vertex_list_graph_archetype::vertices_size_type + num_vertices(const vertex_list_graph_archetype& ) + { + return 0; + } + + // ambiguously inherited from incidence graph and adjacency graph + template + typename vertex_list_graph_archetype::degree_size_type + out_degree(const V&, const vertex_list_graph_archetype& ) + { + return 0; + } + + //=========================================================================== + + struct property_graph_archetype_tag { }; + + template + struct property_graph_archetype : public GraphArchetype + { + typedef property_graph_archetype_tag graph_tag; + typedef ValueArch vertex_property_type; + typedef ValueArch edge_property_type; + }; + + struct choose_edge_property_map_archetype { + template + struct bind_ { + typedef mutable_lvalue_property_map_archetype + type; + typedef lvalue_property_map_archetype + const_type; + }; + }; + template <> + struct edge_property_selector { + typedef choose_edge_property_map_archetype type; + }; + + struct choose_vertex_property_map_archetype { + template + struct bind_ { + typedef mutable_lvalue_property_map_archetype + type; + typedef lvalue_property_map_archetype + const_type; + }; + }; + + template <> + struct vertex_property_selector { + typedef choose_vertex_property_map_archetype type; + }; + + template + typename property_map, P>::type + get(P, property_graph_archetype&) { + typename property_map, P>::type pmap; + return pmap; + } + + template + typename property_map, P>::const_type + get(P, const property_graph_archetype&) { + typename property_map, P>::const_type pmap; + return pmap; + } + + template + typename property_traits, P>::const_type>::value_type + get(P p, const property_graph_archetype& g, K k) { + return get( get(p, g), k); + } + + template + void + put(P p, property_graph_archetype& g, + const Key& key, const V& value) + { + typedef typename boost::property_map, P>::type Map; + Map pmap = get(p, g); + put(pmap, key, value); + } + + struct color_value_archetype { + color_value_archetype() { } + color_value_archetype(detail::dummy_constructor) { } + bool operator==(const color_value_archetype& ) const { return true; } + bool operator!=(const color_value_archetype& ) const { return true; } + }; + template <> + struct color_traits { + static color_value_archetype white() + { + return color_value_archetype + (static_object::get()); + } + static color_value_archetype gray() + { + return color_value_archetype + (static_object::get()); + } + static color_value_archetype black() + { + return color_value_archetype + (static_object::get()); + } + }; + + template + class buffer_archetype { + public: + void push(const T&) {} + void pop() {} + T& top() { return static_object::get(); } + const T& top() const { return static_object::get(); } + bool empty() const { return true; } + }; + +} // namespace boost + + +#endif // BOOST_GRAPH_ARCHETYPES_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/graph_as_tree.hpp b/deal.II/contrib/boost/include/boost/graph/graph_as_tree.hpp new file mode 100644 index 0000000000..7619dfcc0a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_as_tree.hpp @@ -0,0 +1,154 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_GRAPH_AS_TREE_HPP +#define BOOST_GRAPH_GRAPH_AS_TREE_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + class graph_as_tree_base + { + typedef Derived Tree; + public: + typedef Node node_descriptor; + typedef ChIt children_iterator; + + graph_as_tree_base(Graph& g, Node root) : _g(g), _root(root) { } + + friend Node root(const Tree& t) { return t._root; } + + template + friend std::pair + children(N n, const Tree& t) { return adjacent_vertices(n, t._g); } + + template + friend Node parent(N n, const Tree& t) { + return boost::get(t.parent_pa(), n); + } + + Graph& _g; + Node _root; + }; + + struct graph_as_tree_tag { }; + + template ::vertex_descriptor +#endif + , class ChIt +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + = typename graph_traits::adjacency_iterator +#endif + > + class graph_as_tree + : public graph_as_tree_base > + { + typedef graph_as_tree self; + typedef graph_as_tree_base super; + public: + graph_as_tree(Graph& g, Node root) : super(g, root) { } + + graph_as_tree(Graph& g, Node root, ParentMap p) : super(g, root), _p(p) { + breadth_first_search(g, root, + visitor(make_bfs_visitor + (record_predecessors(p, boost::on_tree_edge())))); + } + ParentMap parent_pa() const { return _p; } + typedef graph_as_tree_tag graph_tag; // for property_map + protected: + ParentMap _p; + }; + + + namespace detail { + + struct graph_as_tree_vertex_property_selector { + template + struct bind_ { + typedef typename GraphAsTree::base_type Graph; + typedef property_map PMap; + typedef typename PMap::type type; + typedef typename PMap::const_type const_type; + }; + }; + + struct graph_as_tree_edge_property_selector { + template + struct bind_ { + typedef typename GraphAsTree::base_type Graph; + typedef property_map PMap; + typedef typename PMap::type type; + typedef typename PMap::const_type const_type; + }; + }; + + } // namespace detail + + template <> + struct vertex_property_selector { + typedef detail::graph_as_tree_vertex_property_selector type; + }; + + template <> + struct edge_property_selector { + typedef detail::graph_as_tree_edge_property_selector type; + }; + + template + typename property_map::type + get(Property p, graph_as_tree& g) + { + return get(p, g._g); + } + + template + typename property_map::const_type + get(Property p, const graph_as_tree& g) + { + const Graph& gref = g._g; // in case GRef is non-const + return get(p, gref); + } + + template + typename property_traits< + typename property_map::const_type + >::value_type + get(Property p, const graph_as_tree& g, const Key& k) + { + return get(p, g._g, k); + } + + template + void + put(Property p, const graph_as_tree& g, const Key& k, + const Value& val) + { + put(p, g._g, k, val); + } + +} // namespace boost + +#endif // BOOST_GRAPH_GRAPH_AS_TREE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/graph_concepts.hpp b/deal.II/contrib/boost/include/boost/graph/graph_concepts.hpp new file mode 100644 index 0000000000..a457265016 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_concepts.hpp @@ -0,0 +1,492 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_CONCEPTS_HPP +#define BOOST_GRAPH_CONCEPTS_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + struct MultiPassInputIteratorConcept { + void constraints() { + function_requires< InputIteratorConcept >(); + } + }; + + template + struct GraphConcept + { + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef typename graph_traits::directed_category directed_category; + typedef typename graph_traits::edge_parallel_category + edge_parallel_category; + typedef typename graph_traits::traversal_category + traversal_category; + void constraints() { + function_requires< DefaultConstructibleConcept >(); + function_requires< EqualityComparableConcept >(); + function_requires< AssignableConcept >(); + } + G g; + }; + + template + struct IncidenceGraphConcept + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename graph_traits::out_edge_iterator + out_edge_iterator; + typedef typename graph_traits::traversal_category + traversal_category; + void constraints() { + function_requires< GraphConcept >(); + function_requires< MultiPassInputIteratorConcept >(); + function_requires< DefaultConstructibleConcept >(); + function_requires< EqualityComparableConcept >(); + function_requires< AssignableConcept >(); + function_requires< ConvertibleConcept >(); + + p = out_edges(u, g); + n = out_degree(u, g); + e = *p.first; + u = source(e, g); + v = target(e, g); + const_constraints(g); + } + void const_constraints(const G& cg) { + p = out_edges(u, cg); + n = out_degree(u, cg); + e = *p.first; + u = source(e, cg); + v = target(e, cg); + } + std::pair p; + typename graph_traits::vertex_descriptor u, v; + typename graph_traits::edge_descriptor e; + typename graph_traits::degree_size_type n; + G g; + }; + + template + struct BidirectionalGraphConcept + { + typedef typename graph_traits::in_edge_iterator + in_edge_iterator; + typedef typename graph_traits::traversal_category + traversal_category; + void constraints() { + function_requires< IncidenceGraphConcept >(); + function_requires< MultiPassInputIteratorConcept >(); + function_requires< ConvertibleConcept >(); + + p = in_edges(v, g); + n = in_degree(v, g); + e = *p.first; + const_constraints(g); + } + void const_constraints(const G& cg) { + p = in_edges(v, cg); + n = in_degree(v, cg); + e = *p.first; + } + std::pair p; + typename graph_traits::vertex_descriptor v; + typename graph_traits::edge_descriptor e; + typename graph_traits::degree_size_type n; + G g; + }; + + template + struct AdjacencyGraphConcept + { + typedef typename graph_traits::adjacency_iterator + adjacency_iterator; + typedef typename graph_traits::traversal_category + traversal_category; + void constraints() { + function_requires< GraphConcept >(); + function_requires< MultiPassInputIteratorConcept >(); + function_requires< ConvertibleConcept >(); + + p = adjacent_vertices(v, g); + v = *p.first; + const_constraints(g); + } + void const_constraints(const G& cg) { + p = adjacent_vertices(v, cg); + } + std::pair p; + typename graph_traits::vertex_descriptor v; + G g; + }; + +// dwa 2003/7/11 -- This clearly shouldn't be necessary, but if +// you want to use vector_as_graph, it is! I'm sure the graph +// library leaves these out all over the place. Probably a +// redesign involving specializing a template with a static +// member function is in order :( +// +// It is needed in order to allow us to write using boost::vertices as +// needed for ADL when using vector_as_graph below. +#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) \ + && !BOOST_WORKAROUND(__GNUC__, <= 2) \ + && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# define BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK +#endif + +#ifdef BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK +template +typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&); +#endif + + template + struct VertexListGraphConcept + { + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename graph_traits::vertices_size_type vertices_size_type; + typedef typename graph_traits::traversal_category + traversal_category; + void constraints() { + function_requires< GraphConcept >(); + function_requires< MultiPassInputIteratorConcept >(); + function_requires< ConvertibleConcept >(); + +#ifdef BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK + // dwa 2003/7/11 -- This clearly shouldn't be necessary, but if + // you want to use vector_as_graph, it is! I'm sure the graph + // library leaves these out all over the place. Probably a + // redesign involving specializing a template with a static + // member function is in order :( + using boost::vertices; +#endif + p = vertices(g); + v = *p.first; + const_constraints(g); + } + void const_constraints(const G& cg) { +#ifdef BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK + // dwa 2003/7/11 -- This clearly shouldn't be necessary, but if + // you want to use vector_as_graph, it is! I'm sure the graph + // library leaves these out all over the place. Probably a + // redesign involving specializing a template with a static + // member function is in order :( + using boost::vertices; +#endif + + p = vertices(cg); + v = *p.first; + V = num_vertices(cg); + } + std::pair p; + typename graph_traits::vertex_descriptor v; + G g; + vertices_size_type V; + }; + + template + struct EdgeListGraphConcept + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + typedef typename graph_traits::edge_iterator edge_iterator; + typedef typename graph_traits::edges_size_type edges_size_type; + typedef typename graph_traits::traversal_category + traversal_category; + void constraints() { + function_requires< GraphConcept >(); + function_requires< MultiPassInputIteratorConcept >(); + function_requires< DefaultConstructibleConcept >(); + function_requires< EqualityComparableConcept >(); + function_requires< AssignableConcept >(); + function_requires< ConvertibleConcept >(); + + p = edges(g); + e = *p.first; + u = source(e, g); + v = target(e, g); + const_constraints(g); + } + void const_constraints(const G& cg) { + p = edges(cg); + E = num_edges(cg); + e = *p.first; + u = source(e, cg); + v = target(e, cg); + } + std::pair p; + typename graph_traits::vertex_descriptor u, v; + typename graph_traits::edge_descriptor e; + edges_size_type E; + G g; + }; + + template + struct VertexAndEdgeListGraphConcept + { + void constraints() { + function_requires< VertexListGraphConcept >(); + function_requires< EdgeListGraphConcept >(); + } + }; + + // Where to put the requirement for this constructor? + // G g(n_vertices); + // Not in mutable graph, then LEDA graph's can't be models of + // MutableGraph. + + template + struct EdgeMutableGraphConcept + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + void constraints() { + p = add_edge(u, v, g); + remove_edge(u, v, g); + remove_edge(e, g); + clear_vertex(v, g); + } + G g; + edge_descriptor e; + std::pair p; + typename graph_traits::vertex_descriptor u, v; + }; + + template + struct VertexMutableGraphConcept + { + void constraints() { + v = add_vertex(g); + remove_vertex(v, g); + } + G g; + typename graph_traits::vertex_descriptor u, v; + }; + + template + struct MutableGraphConcept + { + void constraints() { + function_requires< EdgeMutableGraphConcept >(); + function_requires< VertexMutableGraphConcept >(); + } + }; + + template + struct dummy_edge_predicate { + bool operator()(const edge_descriptor&) const { + return false; + } + }; + + template + struct MutableIncidenceGraphConcept + { + void constraints() { + function_requires< MutableGraphConcept >(); + remove_edge(iter, g); + remove_out_edge_if(u, p, g); + } + G g; + typedef typename graph_traits::edge_descriptor edge_descriptor; + dummy_edge_predicate p; + typename boost::graph_traits::vertex_descriptor u; + typename boost::graph_traits::out_edge_iterator iter; + }; + + template + struct MutableBidirectionalGraphConcept + { + void constraints() { + function_requires< MutableIncidenceGraphConcept >(); + remove_in_edge_if(u, p, g); + } + G g; + typedef typename graph_traits::edge_descriptor edge_descriptor; + dummy_edge_predicate p; + typename boost::graph_traits::vertex_descriptor u; + }; + + template + struct MutableEdgeListGraphConcept + { + void constraints() { + function_requires< EdgeMutableGraphConcept >(); + remove_edge_if(p, g); + } + G g; + typedef typename graph_traits::edge_descriptor edge_descriptor; + dummy_edge_predicate p; + }; + + template + struct VertexMutablePropertyGraphConcept + { + void constraints() { + function_requires< VertexMutableGraphConcept >(); + v = add_vertex(vp, g); + } + G g; + typename graph_traits::vertex_descriptor v; + typename vertex_property::type vp; + }; + + template + struct EdgeMutablePropertyGraphConcept + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + void constraints() { + function_requires< EdgeMutableGraphConcept >(); + p = add_edge(u, v, ep, g); + } + G g; + std::pair p; + typename graph_traits::vertex_descriptor u, v; + typename edge_property::type ep; + }; + + template + struct AdjacencyMatrixConcept + { + typedef typename graph_traits::edge_descriptor edge_descriptor; + void constraints() { + function_requires< GraphConcept >(); + + p = edge(u, v, g); + const_constraints(g); + } + void const_constraints(const G& cg) { + p = edge(u, v, cg); + } + typename graph_traits::vertex_descriptor u, v; + std::pair p; + G g; + }; + + template + struct ReadablePropertyGraphConcept + { + typedef typename property_map::const_type const_Map; + void constraints() { + function_requires< GraphConcept >(); + function_requires< ReadablePropertyMapConcept >(); + + const_constraints(g); + } + void const_constraints(const G& cg) { + const_Map pmap = get(Property(), cg); + pval = get(Property(), cg, x); + ignore_unused_variable_warning(pmap); + } + G g; + X x; + typename property_traits::value_type pval; + }; + + template + struct PropertyGraphConcept + { + typedef typename property_map::type Map; + void constraints() { + function_requires< ReadablePropertyGraphConcept >(); + function_requires< ReadWritePropertyMapConcept >(); + + Map pmap = get(Property(), g); + pval = get(Property(), g, x); + put(Property(), g, x, pval); + ignore_unused_variable_warning(pmap); + } + G g; + X x; + typename property_traits::value_type pval; + }; + + template + struct LvaluePropertyGraphConcept + { + typedef typename property_map::type Map; + typedef typename property_map::const_type const_Map; + void constraints() { + function_requires< ReadablePropertyGraphConcept >(); + function_requires< LvaluePropertyMapConcept >(); + + pval = get(Property(), g, x); + put(Property(), g, x, pval); + } + G g; + X x; + typename property_traits::value_type pval; + }; + + // This needs to move out of the graph library + template + struct BufferConcept + { + void constraints() { + b.push(t); + b.pop(); + typename B::value_type& v = b.top(); + const_constraints(b); + ignore_unused_variable_warning(v); + } + void const_constraints(const B& cb) { + const typename B::value_type& v = cb.top(); + n = cb.size(); + bool e = cb.empty(); + ignore_unused_variable_warning(v); + ignore_unused_variable_warning(e); + } + typename B::size_type n; + typename B::value_type t; + B b; + }; + + template + struct ColorValueConcept + { + void constraints() { + function_requires< EqualityComparableConcept >(); + function_requires< DefaultConstructibleConcept >(); + + c = color_traits::white(); + c = color_traits::gray(); + c = color_traits::black(); + } + C c; + }; + + template + struct BasicMatrixConcept + { + void constraints() { + V& elt = A[i][j]; + const_constraints(A); + ignore_unused_variable_warning(elt); + } + void const_constraints(const M& cA) { + const V& elt = cA[i][j]; + ignore_unused_variable_warning(elt); + } + M A; + I i, j; + }; + +} // namespace boost + +#endif /* BOOST_GRAPH_CONCEPTS_H */ diff --git a/deal.II/contrib/boost/include/boost/graph/graph_selectors.hpp b/deal.II/contrib/boost/include/boost/graph/graph_selectors.hpp new file mode 100644 index 0000000000..a3223c9b19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_selectors.hpp @@ -0,0 +1,36 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_SELECTORS_HPP +#define BOOST_GRAPH_SELECTORS_HPP + +namespace boost { + + //=========================================================================== + // Selectors for the Directed template parameter of adjacency_list + // and adjacency_matrix. + + struct directedS { enum { is_directed = true, is_bidir = false }; + typedef true_type is_directed_t; + typedef false_type is_bidir_t; + }; + struct undirectedS { + enum { is_directed = false, is_bidir = false }; + typedef false_type is_directed_t; + typedef false_type is_bidir_t; + }; + struct bidirectionalS { + enum { is_directed = true, is_bidir = true }; + typedef true_type is_directed_t; + typedef true_type is_bidir_t; + }; + +} // namespace boost + +#endif // BOOST_GRAPH_SELECTORS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/graph_test.hpp b/deal.II/contrib/boost/include/boost/graph/graph_test.hpp new file mode 100644 index 0000000000..37ded0c733 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_test.hpp @@ -0,0 +1,382 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_TEST_HPP +#define BOOST_GRAPH_TEST_HPP + +#include +#include +#include +#include +#include +#include +#include // for connects + + +// UNDER CONSTRUCTION + +namespace boost { + + template + struct graph_test + { + + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename graph_traits::edge_descriptor edge_t; + typedef typename graph_traits::vertices_size_type v_size_t; + typedef typename graph_traits::degree_size_type deg_size_t; + typedef typename graph_traits::edges_size_type e_size_t; + typedef typename graph_traits::out_edge_iterator out_edge_iter; + typedef typename property_map::type index_map_t; + typedef iterator_property_map::iterator, + index_map_t,vertex_t,vertex_t&> IsoMap; + + struct ignore_vertex { + ignore_vertex() { } + ignore_vertex(vertex_t v) : v(v) { } + bool operator()(vertex_t x) const { return x != v; } + vertex_t v; + }; + struct ignore_edge { + ignore_edge() { } + ignore_edge(edge_t e) : e(e) { } + bool operator()(edge_t x) const { return x != e; } + edge_t e; + }; + struct ignore_edges { + ignore_edges(vertex_t s, vertex_t t, const Graph& g) + : s(s), t(t), g(g) { } + bool operator()(edge_t x) const { + return !(source(x, g) == s && target(x, g) == t); + } + vertex_t s; vertex_t t; const Graph& g; + }; + + //========================================================================= + // Traversal Operations + + void test_incidence_graph + (const std::vector& vertex_set, + const std::vector< std::pair >& edge_set, + const Graph& g) + { + typedef typename std::vector::const_iterator vertex_iter; + typedef typename std::vector< std::pair > + ::const_iterator edge_iter; + typedef typename graph_traits::out_edge_iterator out_edge_iter; + + for (vertex_iter ui = vertex_set.begin(); ui != vertex_set.end(); ++ui) { + vertex_t u = *ui; + std::vector adj; + for (edge_iter e = edge_set.begin(); e != edge_set.end(); ++e) + if (e->first == u) + adj.push_back(e->second); + + std::pair p = out_edges(u, g); + BOOST_CHECK(out_degree(u, g) == adj.size()); + BOOST_CHECK(deg_size_t(std::distance(p.first, p.second)) + == out_degree(u, g)); + for (; p.first != p.second; ++p.first) { + edge_t e = *p.first; + BOOST_CHECK(source(e, g) == u); + BOOST_CHECK(contains(adj, target(e, g)) == true); + } + } + } + + void test_bidirectional_graph + (const std::vector& vertex_set, + const std::vector< std::pair >& edge_set, + const Graph& g) + { + typedef typename std::vector::const_iterator vertex_iter; + typedef typename std::vector< std::pair > + ::const_iterator edge_iter; + typedef typename graph_traits::in_edge_iterator in_edge_iter; + + for (vertex_iter vi = vertex_set.begin(); vi != vertex_set.end(); ++vi) { + vertex_t v = *vi; + std::vector inv_adj; + for (edge_iter e = edge_set.begin(); e != edge_set.end(); ++e) + if (e->second == v) + inv_adj.push_back(e->first); + + std::pair p = in_edges(v, g); + BOOST_CHECK(in_degree(v, g) == inv_adj.size()); + BOOST_CHECK(deg_size_t(std::distance(p.first, p.second)) + == in_degree(v, g)); + for (; p.first != p.second; ++p.first) { + edge_t e = *p.first; + BOOST_CHECK(target(e, g) == v); + BOOST_CHECK(contains(inv_adj, source(e, g)) == true); + } + } + } + + void test_adjacency_graph + (const std::vector& vertex_set, + const std::vector< std::pair >& edge_set, + const Graph& g) + { + typedef typename std::vector::const_iterator vertex_iter; + typedef typename std::vector > + ::const_iterator edge_iter; + typedef typename graph_traits::adjacency_iterator adj_iter; + + for (vertex_iter ui = vertex_set.begin(); ui != vertex_set.end(); ++ui) { + vertex_t u = *ui; + std::vector adj; + for (edge_iter e = edge_set.begin(); e != edge_set.end(); ++e) + if (e->first == u) + adj.push_back(e->second); + + std::pair p = adjacent_vertices(u, g); + BOOST_CHECK(deg_size_t(std::distance(p.first, p.second)) == adj.size()); + for (; p.first != p.second; ++p.first) { + vertex_t v = *p.first; + BOOST_CHECK(contains(adj, v) == true); + } + } + } + + void test_vertex_list_graph + (const std::vector& vertex_set, const Graph& g) + { + typedef typename graph_traits::vertex_iterator v_iter; + std::pair p = vertices(g); + BOOST_CHECK(num_vertices(g) == vertex_set.size()); + v_size_t n = std::distance(p.first, p.second); + BOOST_CHECK(n == num_vertices(g)); + for (; p.first != p.second; ++p.first) { + vertex_t v = *p.first; + BOOST_CHECK(contains(vertex_set, v) == true); + } + } + + void test_edge_list_graph + (const std::vector& vertex_set, + const std::vector< std::pair >& edge_set, + const Graph& g) + { + typedef typename graph_traits::edge_iterator e_iter; + std::pair p = edges(g); + BOOST_CHECK(num_edges(g) == edge_set.size()); + e_size_t m = std::distance(p.first, p.second); + BOOST_CHECK(m == num_edges(g)); + for (; p.first != p.second; ++p.first) { + edge_t e = *p.first; + BOOST_CHECK(any_if(edge_set, connects(source(e, g), target(e, g), g))); + BOOST_CHECK(contains(vertex_set, source(e, g)) == true); + BOOST_CHECK(contains(vertex_set, target(e, g)) == true); + } + } + + void test_adjacency_matrix + (const std::vector& vertex_set, + const std::vector< std::pair >& edge_set, + const Graph& g) + { + std::pair p; + for (typename std::vector > + ::const_iterator i = edge_set.begin(); + i != edge_set.end(); ++i) { + p = edge(i->first, i->second, g); + BOOST_CHECK(p.second == true); + BOOST_CHECK(source(p.first, g) == i->first); + BOOST_CHECK(target(p.first, g) == i->second); + } + typename std::vector::const_iterator j, k; + for (j = vertex_set.begin(); j != vertex_set.end(); ++j) + for (k = vertex_set.begin(); k != vertex_set.end(); ++k) { + p = edge(*j, *k, g); + if (p.second == true) + BOOST_CHECK(any_if(edge_set, + connects(source(p.first, g), target(p.first, g), g)) == true); + } + } + + //========================================================================= + // Mutating Operations + + void test_add_vertex(Graph& g) + { + Graph cpy; + std::vector iso_vec(num_vertices(g)); + IsoMap iso_map(iso_vec.begin(), get(vertex_index, g)); + copy_graph(g, cpy, orig_to_copy(iso_map)); + + assert((verify_isomorphism(g, cpy, iso_map))); + + vertex_t v = add_vertex(g); + + BOOST_CHECK(num_vertices(g) == num_vertices(cpy) + 1); + + BOOST_CHECK(out_degree(v, g) == 0); + + // Make sure the rest of the graph stayed the same + BOOST_CHECK((verify_isomorphism + (make_filtered_graph(g, keep_all(), ignore_vertex(v)), cpy, + iso_map))); + } + + void test_add_edge(vertex_t u, vertex_t v, Graph& g) + { + Graph cpy; + std::vector iso_vec(num_vertices(g)); + IsoMap iso_map(iso_vec.begin(), get(vertex_index, g)); + copy_graph(g, cpy, orig_to_copy(iso_map)); + + bool parallel_edge_exists = contains(adjacent_vertices(u, g), v); + + std::pair p = add_edge(u, v, g); + edge_t e = p.first; + bool added = p.second; + + if (is_undirected(g) && u == v) // self edge + BOOST_CHECK(added == false); + else if (parallel_edge_exists) + BOOST_CHECK(allows_parallel_edges(g) && added == true + || !allows_parallel_edges(g) && added == false); + else + BOOST_CHECK(added == true); + + if (p.second == true) { // edge added + BOOST_CHECK(num_edges(g) == num_edges(cpy) + 1); + + BOOST_CHECK(contains(out_edges(u, g), e) == true); + + BOOST_CHECK((verify_isomorphism + (make_filtered_graph(g, ignore_edge(e)), cpy, iso_map))); + } + else { // edge not added + if (! (is_undirected(g) && u == v)) { + // e should be a parallel edge + BOOST_CHECK(source(e, g) == u); + BOOST_CHECK(target(e, g) == v); + } + // The graph should not be changed. + BOOST_CHECK((verify_isomorphism(g, cpy, iso_map))); + } + } // test_add_edge() + + + void test_remove_edge(vertex_t u, vertex_t v, Graph& g) + { + Graph cpy; + std::vector iso_vec(num_vertices(g)); + IsoMap iso_map(iso_vec.begin(), get(vertex_index, g)); + copy_graph(g, cpy, orig_to_copy(iso_map)); + + deg_size_t occurances = count(adjacent_vertices(u, g), v); + + remove_edge(u, v, g); + + BOOST_CHECK(num_edges(g) + occurances == num_edges(cpy)); + BOOST_CHECK((verify_isomorphism + (g, make_filtered_graph(cpy, ignore_edges(u,v,cpy)), + iso_map))); + } + + void test_remove_edge(edge_t e, Graph& g) + { + Graph cpy; + std::vector iso_vec(num_vertices(g)); + IsoMap iso_map(iso_vec.begin(), get(vertex_index, g)); + copy_graph(g, cpy, orig_to_copy(iso_map)); + + vertex_t u = source(e, g), v = target(e, g); + deg_size_t occurances = count(adjacent_vertices(u, g), v); + + remove_edge(e, g); + + BOOST_CHECK(num_edges(g) + 1 == num_edges(cpy)); + BOOST_CHECK(count(adjacent_vertices(u, g), v) + 1 == occurances); + BOOST_CHECK((verify_isomorphism + (g, make_filtered_graph(cpy, ignore_edge(e)), + iso_map))); + } + + void test_clear_vertex(vertex_t v, Graph& g) + { + Graph cpy; + std::vector iso_vec(num_vertices(g)); + IsoMap iso_map(iso_vec.begin(), get(vertex_index, g)); + copy_graph(g, cpy, orig_to_copy(iso_map)); + + clear_vertex(v, g); + + BOOST_CHECK(out_degree(v, g) == 0); + BOOST_CHECK(num_vertices(g) == num_vertices(cpy)); + BOOST_CHECK((verify_isomorphism + (g, make_filtered_graph(cpy, keep_all(), ignore_vertex(v)), + iso_map))); + } + + //========================================================================= + // Property Map + + template + void test_readable_vertex_property_graph + (const std::vector& vertex_prop, PropertyTag, const Graph& g) + { + typedef typename property_map::const_type const_Map; + const_Map pmap = get(PropertyTag(), g); + typename std::vector::const_iterator i = vertex_prop.begin(); + + for (typename boost::graph_traits::vertex_iterator + bgl_first_9 = vertices(g).first, bgl_last_9 = vertices(g).second; + bgl_first_9 != bgl_last_9; bgl_first_9 = bgl_last_9) + for (typename boost::graph_traits::vertex_descriptor v; + bgl_first_9 != bgl_last_9 ? (v = *bgl_first_9, true) : false; + ++bgl_first_9) { + //BGL_FORALL_VERTICES_T(v, g, Graph) { + typename property_traits::value_type + pval1 = get(pmap, v), pval2 = get(PropertyTag(), g, v); + BOOST_CHECK(pval1 == pval2); + BOOST_CHECK(pval1 == *i++); + } + } + + template + void test_vertex_property_graph + (const std::vector& vertex_prop, PropertyTag tag, Graph& g) + { + typedef typename property_map::type PMap; + PMap pmap = get(PropertyTag(), g); + typename std::vector::const_iterator i = vertex_prop.begin(); + for (typename boost::graph_traits::vertex_iterator + bgl_first_9 = vertices(g).first, bgl_last_9 = vertices(g).second; + bgl_first_9 != bgl_last_9; bgl_first_9 = bgl_last_9) + for (typename boost::graph_traits::vertex_descriptor v; + bgl_first_9 != bgl_last_9 ? (v = *bgl_first_9, true) : false; + ++bgl_first_9) + // BGL_FORALL_VERTICES_T(v, g, Graph) + put(pmap, v, *i++); + + test_readable_vertex_property_graph(vertex_prop, tag, g); + + BGL_FORALL_VERTICES_T(v, g, Graph) + put(pmap, v, vertex_prop[0]); + + typename std::vector::const_iterator j = vertex_prop.begin(); + BGL_FORALL_VERTICES_T(v, g, Graph) + put(PropertyTag(), g, v, *j++); + + test_readable_vertex_property_graph(vertex_prop, tag, g); + } + + + }; + + +} // namespace boost + +#include + +#endif // BOOST_GRAPH_TEST_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/graph_traits.hpp b/deal.II/contrib/boost/include/boost/graph/graph_traits.hpp new file mode 100644 index 0000000000..1c5a26589b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_traits.hpp @@ -0,0 +1,168 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_TRAITS_HPP +#define BOOST_GRAPH_TRAITS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + struct graph_traits { + typedef typename G::vertex_descriptor vertex_descriptor; + typedef typename G::edge_descriptor edge_descriptor; + typedef typename G::adjacency_iterator adjacency_iterator; + typedef typename G::out_edge_iterator out_edge_iterator; + typedef typename G::in_edge_iterator in_edge_iterator; + typedef typename G::vertex_iterator vertex_iterator; + typedef typename G::edge_iterator edge_iterator; + + typedef typename G::directed_category directed_category; + typedef typename G::edge_parallel_category edge_parallel_category; + typedef typename G::traversal_category traversal_category; + + typedef typename G::vertices_size_type vertices_size_type; + typedef typename G::edges_size_type edges_size_type; + typedef typename G::degree_size_type degree_size_type; + + static inline vertex_descriptor null_vertex(); + }; + + template + inline typename graph_traits::vertex_descriptor + graph_traits::null_vertex() + { + return G::null_vertex(); + } + + // directed_category tags + struct directed_tag { }; + struct undirected_tag { }; + struct bidirectional_tag : public directed_tag { }; + + namespace detail { + inline bool is_directed(directed_tag) { return true; } + inline bool is_directed(undirected_tag) { return false; } + } + + template + bool is_directed(const Graph&) { + typedef typename graph_traits::directed_category Cat; + return detail::is_directed(Cat()); + } + template + bool is_undirected(const Graph& g) { + return ! is_directed(g); + } + + // edge_parallel_category tags + struct allow_parallel_edge_tag {}; + struct disallow_parallel_edge_tag {}; + + namespace detail { + inline bool allows_parallel(allow_parallel_edge_tag) { return true; } + inline bool allows_parallel(disallow_parallel_edge_tag) { return false; } + } + + template + bool allows_parallel_edges(const Graph&) { + typedef typename graph_traits::edge_parallel_category Cat; + return detail::allows_parallel(Cat()); + } + + // traversal_category tags + struct incidence_graph_tag { }; + struct adjacency_graph_tag { }; + struct bidirectional_graph_tag : + public virtual incidence_graph_tag { }; + struct vertex_list_graph_tag { }; + struct edge_list_graph_tag { }; + struct adjacency_matrix_tag { }; + + //?? not the right place ?? Lee + typedef boost::forward_traversal_tag multi_pass_input_iterator_tag; + + template + struct edge_property_type { + typedef typename G::edge_property_type type; + }; + template + struct vertex_property_type { + typedef typename G::vertex_property_type type; + }; + template + struct graph_property_type { + typedef typename G::graph_property_type type; + }; + + struct no_vertex_bundle {}; + struct no_edge_bundle {}; + + template + struct vertex_bundle_type + { + typedef typename G::vertex_bundled type; + }; + + template + struct edge_bundle_type + { + typedef typename G::edge_bundled type; + }; + + namespace graph { namespace detail { + template + class bundled_result + { + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename mpl::if_c<(is_same::value), + vertex_bundle_type, + edge_bundle_type >::type bundler; + + public: + typedef typename bundler::type type; + }; + } } // end namespace graph::detail +} // namespace boost + +// Since pair is in namespace std, Koenig lookup will find source and +// target if they are also defined in namespace std. This is illegal, +// but the alternative is to put source and target in the global +// namespace which causes name conflicts with other libraries (like +// SUIF). +namespace std { + + /* Some helper functions for dealing with pairs as edges */ + template + T source(pair p, const G&) { return p.first; } + + template + T target(pair p, const G&) { return p.second; } + +} + +#if defined(__GNUC__) && defined(__SGI_STL_PORT) +// For some reason g++ with STLport does not see the above definition +// of source() and target() unless we bring them into the boost +// namespace. +namespace boost { + using std::source; + using std::target; +} +#endif + +#endif // BOOST_GRAPH_TRAITS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/graph_utility.hpp b/deal.II/contrib/boost/include/boost/graph/graph_utility.hpp new file mode 100644 index 0000000000..54fdda71cc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graph_utility.hpp @@ -0,0 +1,419 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_UTILITY_HPP +#define BOOST_GRAPH_UTILITY_HPP + +#include +#include +#include +#include +#include +#include +#ifndef BOOST_NO_SLIST +# include // shouldn't have to include this... -JGS +#endif +#include +#include +#include +#include +// iota moved to detail/algorithm.hpp +#include + +namespace boost { + + // Provide an undirected graph interface alternative to the + // the source() and target() edge functions. + template + inline + std::pair::vertex_descriptor, + typename graph_traits::vertex_descriptor> + incident(typename graph_traits::edge_descriptor e, + UndirectedGraph& g) + { + return std::make_pair(source(e,g), target(e,g)); + } + + // Provide an undirected graph interface alternative + // to the out_edges() function. + template + inline + std::pair::out_edge_iterator, + typename graph_traits::out_edge_iterator> + incident_edges(typename graph_traits::vertex_descriptor u, + Graph& g) + { + return out_edges(u, g); + } + + template + inline typename graph_traits::vertex_descriptor + opposite(typename graph_traits::edge_descriptor e, + typename graph_traits::vertex_descriptor v, + const Graph& g) + { + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + if (v == source(e, g)) + return target(e, g); + else if (v == target(e, g)) + return source(e, g); + else + return vertex_descriptor(); + } + + //=========================================================================== + // Some handy predicates + + template + struct incident_from_predicate { + incident_from_predicate(Vertex u, const Graph& g) + : m_u(u), m_g(g) { } + template + bool operator()(const Edge& e) const { + return source(e, m_g) == m_u; + } + Vertex m_u; + const Graph& m_g; + }; + template + inline incident_from_predicate + incident_from(Vertex u, const Graph& g) { + return incident_from_predicate(u, g); + } + + template + struct incident_to_predicate { + incident_to_predicate(Vertex u, const Graph& g) + : m_u(u), m_g(g) { } + template + bool operator()(const Edge& e) const { + return target(e, m_g) == m_u; + } + Vertex m_u; + const Graph& m_g; + }; + template + inline incident_to_predicate + incident_to(Vertex u, const Graph& g) { + return incident_to_predicate(u, g); + } + + template + struct incident_on_predicate { + incident_on_predicate(Vertex u, const Graph& g) + : m_u(u), m_g(g) { } + template + bool operator()(const Edge& e) const { + return source(e, m_g) == m_u || target(e, m_g) == m_u; + } + Vertex m_u; + const Graph& m_g; + }; + template + inline incident_on_predicate + incident_on(Vertex u, const Graph& g) { + return incident_on_predicate(u, g); + } + + template + struct connects_predicate { + connects_predicate(Vertex u, Vertex v, const Graph& g) + : m_u(u), m_v(v), m_g(g) { } + template + bool operator()(const Edge& e) const { + if (is_directed(m_g)) + return source(e, m_g) == m_u && target(e, m_g) == m_v; + else + return (source(e, m_g) == m_u && target(e, m_g) == m_v) + || (source(e, m_g) == m_v && target(e, m_g) == m_u); + } + Vertex m_u, m_v; + const Graph& m_g; + }; + template + inline connects_predicate + connects(Vertex u, Vertex v, const Graph& g) { + return connects_predicate(u, v, g); + } + + + // Need to convert all of these printing functions to take an ostream object + // -JGS + + template + void print_in_edges(const IncidenceGraph& G, Name name) + { + typename graph_traits::vertex_iterator ui,ui_end; + for (tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) { + std::cout << get(name,*ui) << " <-- "; + typename graph_traits + ::in_edge_iterator ei, ei_end; + for(tie(ei,ei_end) = in_edges(*ui,G); ei != ei_end; ++ei) + std::cout << get(name,source(*ei,G)) << " "; + std::cout << std::endl; + } + } + + template + void print_graph_dispatch(const IncidenceGraph& G, Name name, directed_tag) + { + typename graph_traits::vertex_iterator ui,ui_end; + for (tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) { + std::cout << get(name,*ui) << " --> "; + typename graph_traits + ::out_edge_iterator ei, ei_end; + for(tie(ei,ei_end) = out_edges(*ui,G); ei != ei_end; ++ei) + std::cout << get(name,target(*ei,G)) << " "; + std::cout << std::endl; + } + } + template + void print_graph_dispatch(const IncidenceGraph& G, Name name, undirected_tag) + { + typename graph_traits::vertex_iterator ui,ui_end; + for (tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) { + std::cout << get(name,*ui) << " <--> "; + typename graph_traits + ::out_edge_iterator ei, ei_end; + for(tie(ei,ei_end) = out_edges(*ui,G); ei != ei_end; ++ei) + std::cout << get(name,target(*ei,G)) << " "; + std::cout << std::endl; + } + } + template + void print_graph(const IncidenceGraph& G, Name name) + { + typedef typename graph_traits + ::directed_category Cat; + print_graph_dispatch(G, name, Cat()); + } + template + void print_graph(const IncidenceGraph& G) { + print_graph(G, get(vertex_index, G)); + } + + template + void print_edges(const EdgeListGraph& G, Name name) + { + typename graph_traits::edge_iterator ei, ei_end; + for (tie(ei, ei_end) = edges(G); ei != ei_end; ++ei) + std::cout << "(" << get(name, source(*ei, G)) + << "," << get(name, target(*ei, G)) << ") "; + std::cout << std::endl; + } + + template + void print_edges2(const EdgeListGraph& G, VertexName vname, EdgeName ename) + { + typename graph_traits::edge_iterator ei, ei_end; + for (tie(ei, ei_end) = edges(G); ei != ei_end; ++ei) + std::cout << get(ename, *ei) << "(" << get(vname, source(*ei, G)) + << "," << get(vname, target(*ei, G)) << ") "; + std::cout << std::endl; + } + + template + void print_vertices(const VertexListGraph& G, Name name) + { + typename graph_traits::vertex_iterator vi,vi_end; + for (tie(vi,vi_end) = vertices(G); vi != vi_end; ++vi) + std::cout << get(name,*vi) << " "; + std::cout << std::endl; + } + + template + bool is_adj_dispatch(Graph& g, Vertex a, Vertex b, bidirectional_tag) + { + typedef typename graph_traits::edge_descriptor + edge_descriptor; + typename graph_traits::adjacency_iterator vi, viend, + adj_found; + tie(vi, viend) = adjacent_vertices(a, g); + adj_found = std::find(vi, viend, b); + if (adj_found == viend) + return false; + + typename graph_traits::out_edge_iterator oi, oiend, + out_found; + tie(oi, oiend) = out_edges(a, g); + out_found = std::find_if(oi, oiend, incident_to(b, g)); + if (out_found == oiend) + return false; + + typename graph_traits::in_edge_iterator ii, iiend, + in_found; + tie(ii, iiend) = in_edges(b, g); + in_found = std::find_if(ii, iiend, incident_from(a, g)); + if (in_found == iiend) + return false; + + return true; + } + template + bool is_adj_dispatch(Graph& g, Vertex a, Vertex b, directed_tag) + { + typedef typename graph_traits::edge_descriptor + edge_descriptor; + typename graph_traits::adjacency_iterator vi, viend, found; + tie(vi, viend) = adjacent_vertices(a, g); +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && defined(__SGI_STL_PORT) + // Getting internal compiler error with std::find() + found = viend; + for (; vi != viend; ++vi) + if (*vi == b) { + found = vi; + break; + } +#else + found = std::find(vi, viend, b); +#endif + if ( found == viend ) + return false; + + typename graph_traits::out_edge_iterator oi, oiend, + out_found; + tie(oi, oiend) = out_edges(a, g); + +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && defined(__SGI_STL_PORT) + // Getting internal compiler error with std::find() + out_found = oiend; + for (; oi != oiend; ++oi) + if (target(*oi, g) == b) { + out_found = oi; + break; + } +#else + out_found = std::find_if(oi, oiend, incident_to(b, g)); +#endif + if (out_found == oiend) + return false; + return true; + } + template + bool is_adj_dispatch(Graph& g, Vertex a, Vertex b, undirected_tag) + { + return is_adj_dispatch(g, a, b, directed_tag()); + } + + template + bool is_adjacent(Graph& g, Vertex a, Vertex b) { + typedef typename graph_traits::directed_category Cat; + return is_adj_dispatch(g, a, b, Cat()); + } + + template + bool in_edge_set(Graph& g, Edge e) + { + typename Graph::edge_iterator ei, ei_end, found; + tie(ei, ei_end) = edges(g); + found = std::find(ei, ei_end, e); + return found != ei_end; + } + + template + bool in_vertex_set(Graph& g, Vertex v) + { + typename Graph::vertex_iterator vi, vi_end, found; + tie(vi, vi_end) = vertices(g); + found = std::find(vi, vi_end, v); + return found != vi_end; + } + + template + bool in_edge_set(Graph& g, Vertex u, Vertex v) + { + typename Graph::edge_iterator ei, ei_end; + for (tie(ei,ei_end) = edges(g); ei != ei_end; ++ei) + if (source(*ei,g) == u && target(*ei,g) == v) + return true; + return false; + } + + // is x a descendant of y? + template + inline bool is_descendant + (typename property_traits::value_type x, + typename property_traits::value_type y, + ParentMap parent) + { + if (get(parent, x) == x) // x is the root of the tree + return false; + else if (get(parent, x) == y) + return true; + else + return is_descendant(get(parent, x), y, parent); + } + + // is y reachable from x? + template + inline bool is_reachable + (typename graph_traits::vertex_descriptor x, + typename graph_traits::vertex_descriptor y, + const IncidenceGraph& g, + VertexColorMap color) // should start out white for every vertex + { + typedef typename property_traits::value_type ColorValue; + dfs_visitor<> vis; + depth_first_visit(g, x, vis, color); + return get(color, y) != color_traits::white(); + } + + // Is the undirected graph connected? + // Is the directed graph strongly connected? + template + inline bool is_connected(const VertexListGraph& g, VertexColorMap color) + { + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename graph_traits::vertex_iterator + ui, ui_end, vi, vi_end, ci, ci_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + if (*ui != *vi) { + for (tie(ci, ci_end) = vertices(g); ci != ci_end; ++ci) + put(color, *ci, Color::white()); + if (! is_reachable(*ui, *vi, color)) + return false; + } + return true; + } + + template + bool is_self_loop + (typename graph_traits::edge_descriptor e, + const Graph& g) + { + return source(e, g) == target(e, g); + } + + + template + std::pair + make_list(const T1& t1, const T2& t2) + { return std::make_pair(t1, t2); } + + template + std::pair > + make_list(const T1& t1, const T2& t2, const T3& t3) + { return std::make_pair(t1, std::make_pair(t2, t3)); } + + template + std::pair > > + make_list(const T1& t1, const T2& t2, const T3& t3, const T4& t4) + { return std::make_pair(t1, std::make_pair(t2, std::make_pair(t3, t4))); } + + template + std::pair > > > + make_list(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) + { return std::make_pair(t1, std::make_pair(t2, std::make_pair(t3, std::make_pair(t4, t5)))); } + +} /* namespace boost */ + +#endif /* BOOST_GRAPH_UTILITY_HPP*/ diff --git a/deal.II/contrib/boost/include/boost/graph/graphviz.hpp b/deal.II/contrib/boost/include/boost/graph/graphviz.hpp new file mode 100644 index 0000000000..71a304b205 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/graphviz.hpp @@ -0,0 +1,757 @@ +//======================================================================= +// Copyright 2001 University of Notre Dame. +// Copyright 2003 Jeremy Siek +// Authors: Lie-Quan Lee and Jeremy Siek +// +// 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_GRAPHVIZ_HPP +#define BOOST_GRAPHVIZ_HPP + +#include +#include +#include +#include +#include +#include // for FILE +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + struct graphviz_io_traits { + static std::string name() { + return "digraph"; + } + static std::string delimiter() { + return "->"; + } }; + + template <> + struct graphviz_io_traits { + static std::string name() { + return "graph"; + } + static std::string delimiter() { + return "--"; + } + }; + + struct default_writer { + void operator()(std::ostream&) const { + } + template + void operator()(std::ostream&, const VorE&) const { + } + }; + + template + class label_writer { + public: + label_writer(Name _name) : name(_name) {} + template + void operator()(std::ostream& out, const VertexOrEdge& v) const { + out << "[label=\"" << get(name, v) << "\"]"; + } + private: + Name name; + }; + template + inline label_writer + make_label_writer(Name n) { + return label_writer(n); + } + + enum edge_attribute_t { edge_attribute = 1111 }; + enum vertex_attribute_t { vertex_attribute = 2222 }; + enum graph_graph_attribute_t { graph_graph_attribute = 3333 }; + enum graph_vertex_attribute_t { graph_vertex_attribute = 4444 }; + enum graph_edge_attribute_t { graph_edge_attribute = 5555 }; + + BOOST_INSTALL_PROPERTY(edge, attribute); + BOOST_INSTALL_PROPERTY(vertex, attribute); + BOOST_INSTALL_PROPERTY(graph, graph_attribute); + BOOST_INSTALL_PROPERTY(graph, vertex_attribute); + BOOST_INSTALL_PROPERTY(graph, edge_attribute); + + + template + inline void write_attributes(const Attribute& attr, std::ostream& out) { + typename Attribute::const_iterator i, iend; + i = attr.begin(); + iend = attr.end(); + + while ( i != iend ) { + out << i->first << "=\"" << i->second << "\""; + ++i; + if ( i != iend ) + out << ", "; + } + } + + template + inline void write_all_attributes(Attributes attributes, + const std::string& name, + std::ostream& out) + { + typename Attributes::const_iterator i = attributes.begin(), + end = attributes.end(); + if (i != end) { + out << name << " [\n"; + write_attributes(attributes, out); + out << "];\n"; + } + } + + inline void write_all_attributes(detail::error_property_not_found, + const std::string&, + std::ostream&) + { + // Do nothing - no attributes exist + } + + + + + template + struct graph_attributes_writer + { + graph_attributes_writer(GraphGraphAttributes gg, + GraphNodeAttributes gn, + GraphEdgeAttributes ge) + : g_attributes(gg), n_attributes(gn), e_attributes(ge) { } + + void operator()(std::ostream& out) const { + write_all_attributes(g_attributes, "graph", out); + write_all_attributes(n_attributes, "node", out); + write_all_attributes(e_attributes, "edge", out); + } + GraphGraphAttributes g_attributes; + GraphNodeAttributes n_attributes; + GraphEdgeAttributes e_attributes; + }; + + template + graph_attributes_writer + make_graph_attributes_writer(const GAttrMap& g_attr, const NAttrMap& n_attr, + const EAttrMap& e_attr) { + return graph_attributes_writer + (g_attr, n_attr, e_attr); + } + + + template + graph_attributes_writer + ::type, + typename graph_property::type, + typename graph_property::type> + make_graph_attributes_writer(const Graph& g) + { + typedef typename graph_property::type + GAttrMap; + typedef typename graph_property::type + NAttrMap; + typedef typename graph_property::type + EAttrMap; + GAttrMap gam = get_property(g, graph_graph_attribute); + NAttrMap nam = get_property(g, graph_vertex_attribute); + EAttrMap eam = get_property(g, graph_edge_attribute); + graph_attributes_writer writer(gam, nam, eam); + return writer; + } + + template + struct attributes_writer { + attributes_writer(AttributeMap attr) + : attributes(attr) { } + + template + void operator()(std::ostream& out, const VorE& e) const { + this->write_attribute(out, attributes[e]); + } + + private: + template + void write_attribute(std::ostream& out, + const AttributeSequence& seq) const + { + if (!seq.empty()) { + out << "["; + write_attributes(seq, out); + out << "]"; + } + } + + void write_attribute(std::ostream&, + detail::error_property_not_found) const + { + } + AttributeMap attributes; + }; + + template + attributes_writer + ::const_type> + make_edge_attributes_writer(const Graph& g) + { + typedef typename property_map::const_type + EdgeAttributeMap; + return attributes_writer(get(edge_attribute, g)); + } + + template + attributes_writer + ::const_type> + make_vertex_attributes_writer(const Graph& g) + { + typedef typename property_map::const_type + VertexAttributeMap; + return attributes_writer(get(vertex_attribute, g)); + } + + template + inline void write_graphviz(std::ostream& out, const Graph& g, + VertexPropertiesWriter vpw, + EdgePropertiesWriter epw, + GraphPropertiesWriter gpw, + VertexID vertex_id) + { + typedef typename graph_traits::directed_category cat_type; + typedef graphviz_io_traits Traits; + std::string name = "G"; + out << Traits::name() << " " << name << " {" << std::endl; + + gpw(out); //print graph properties + + typename graph_traits::vertex_iterator i, end; + + for(tie(i,end) = vertices(g); i != end; ++i) { + out << get(vertex_id, *i); + vpw(out, *i); //print vertex attributes + out << ";" << std::endl; + } + typename graph_traits::edge_iterator ei, edge_end; + for(tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) { + out << get(vertex_id, source(*ei, g)) << Traits::delimiter() << get(vertex_id, target(*ei, g)) << " "; + epw(out, *ei); //print edge attributes + out << ";" << std::endl; + } + out << "}" << std::endl; + } + + template + inline void write_graphviz(std::ostream& out, const Graph& g, + VertexPropertiesWriter vpw, + EdgePropertiesWriter epw, + GraphPropertiesWriter gpw) + { write_graphviz(out, g, vpw, epw, gpw, get(vertex_index, g)); } + +#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 + // ambiguous overload problem with VC++ + template + inline void + write_graphviz(std::ostream& out, const Graph& g) { + default_writer dw; + default_writer gw; + write_graphviz(out, g, dw, dw, gw); + } +#endif + + template + inline void + write_graphviz(std::ostream& out, const Graph& g, VertexWriter vw) { + default_writer dw; + default_writer gw; + write_graphviz(out, g, vw, dw, gw); + } + + template + inline void + write_graphviz(std::ostream& out, const Graph& g, + VertexWriter vw, EdgeWriter ew) { + default_writer gw; + write_graphviz(out, g, vw, ew, gw); + } + + namespace detail { + + template + void write_graphviz_subgraph (std::ostream& out, + const subgraph& g, + RandomAccessIterator vertex_marker, + RandomAccessIterator edge_marker, + VertexID vertex_id) + { + typedef subgraph Graph; + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename graph_traits::directed_category cat_type; + typedef graphviz_io_traits Traits; + + typedef typename graph_property::type NameType; + const NameType& g_name = get_property(g, graph_name); + + if ( g.is_root() ) + out << Traits::name() ; + else + out << "subgraph"; + + out << " " << g_name << " {" << std::endl; + + typename Graph::const_children_iterator i_child, j_child; + + //print graph/node/edge attributes +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + typedef typename graph_property::type + GAttrMap; + typedef typename graph_property::type + NAttrMap; + typedef typename graph_property::type + EAttrMap; + GAttrMap gam = get_property(g, graph_graph_attribute); + NAttrMap nam = get_property(g, graph_vertex_attribute); + EAttrMap eam = get_property(g, graph_edge_attribute); + graph_attributes_writer writer(gam, nam, eam); + writer(out); +#else + make_graph_attributes_writer(g)(out); +#endif + + //print subgraph + for ( tie(i_child,j_child) = g.children(); + i_child != j_child; ++i_child ) + write_graphviz_subgraph(out, *i_child, vertex_marker, edge_marker, + vertex_id); + + // Print out vertices and edges not in the subgraphs. + + typename graph_traits::vertex_iterator i, end; + typename graph_traits::edge_iterator ei, edge_end; + + for(tie(i,end) = vertices(g); i != end; ++i) { + Vertex v = g.local_to_global(*i); + int pos = get(vertex_id, v); + if ( vertex_marker[pos] ) { + vertex_marker[pos] = false; + out << pos; +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + typedef typename property_map::const_type + VertexAttributeMap; + attributes_writer vawriter(get(vertex_attribute, + g.root())); + vawriter(out, v); +#else + make_vertex_attributes_writer(g.root())(out, v); +#endif + out << ";" << std::endl; + } + } + + for (tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) { + Vertex u = g.local_to_global(source(*ei,g)), + v = g.local_to_global(target(*ei, g)); + int pos = get(get(edge_index, g.root()), g.local_to_global(*ei)); + if ( edge_marker[pos] ) { + edge_marker[pos] = false; + out << get(vertex_id, u) << " " << Traits::delimiter() + << " " << get(vertex_id, v); +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + typedef typename property_map::const_type + EdgeAttributeMap; + attributes_writer eawriter(get(edge_attribute, g)); + eawriter(out, *ei); +#else + make_edge_attributes_writer(g)(out, *ei); //print edge properties +#endif + out << ";" << std::endl; + } + } + out << "}" << std::endl; + } + } // namespace detail + + // requires graph_name graph property + template + void write_graphviz(std::ostream& out, const subgraph& g) { + std::vector edge_marker(num_edges(g), true); + std::vector vertex_marker(num_vertices(g), true); + + detail::write_graphviz_subgraph(out, g, + vertex_marker.begin(), + edge_marker.begin(), + get(vertex_index, g)); + } + + template + void write_graphviz(const std::string& filename, const subgraph& g) { + std::ofstream out(filename.c_str()); + std::vector edge_marker(num_edges(g), true); + std::vector vertex_marker(num_vertices(g), true); + + detail::write_graphviz_subgraph(out, g, + vertex_marker.begin(), + edge_marker.begin(), + get(vertex_index, g)); + } + + template + void write_graphviz(std::ostream& out, const subgraph& g, + VertexID vertex_id) + { + std::vector edge_marker(num_edges(g), true); + std::vector vertex_marker(num_vertices(g), true); + + detail::write_graphviz_subgraph(out, g, + vertex_marker.begin(), + edge_marker.begin(), + vertex_id); + } + + template + void write_graphviz(const std::string& filename, const subgraph& g, + VertexID vertex_id) + { + std::ofstream out(filename.c_str()); + std::vector edge_marker(num_edges(g), true); + std::vector vertex_marker(num_vertices(g), true); + + detail::write_graphviz_subgraph(out, g, + vertex_marker.begin(), + edge_marker.begin(), + vertex_id); + } + + typedef std::map GraphvizAttrList; + + typedef property + GraphvizVertexProperty; + + typedef property > + GraphvizEdgeProperty; + + typedef property > > > + GraphvizGraphProperty; + + typedef subgraph > + GraphvizDigraph; + + typedef subgraph > + GraphvizGraph; + + + // These four require linking the BGL-Graphviz library: libbgl-viz.a + // from the /src directory. + extern void read_graphviz(const std::string& file, GraphvizDigraph& g); + extern void read_graphviz(FILE* file, GraphvizDigraph& g); + + extern void read_graphviz(const std::string& file, GraphvizGraph& g); + extern void read_graphviz(FILE* file, GraphvizGraph& g); + + class dynamic_properties_writer + { + public: + dynamic_properties_writer(const dynamic_properties& dp) : dp(&dp) { } + + template + void operator()(std::ostream& out, Descriptor key) const + { + bool first = true; + for (dynamic_properties::const_iterator i = dp->begin(); + i != dp->end(); ++i) { + if (typeid(key) == i->second->key()) { + if (first) out << " ["; + else out << ", "; + first = false; + + out << i->first << "=\"" << i->second->get_string(key) << "\""; + } + } + + if (!first) out << "]"; + } + + private: + const dynamic_properties* dp; + }; + + class dynamic_vertex_properties_writer + { + public: + dynamic_vertex_properties_writer(const dynamic_properties& dp, + const std::string& node_id) + : dp(&dp), node_id(&node_id) { } + + template + void operator()(std::ostream& out, Descriptor key) const + { + bool first = true; + for (dynamic_properties::const_iterator i = dp->begin(); + i != dp->end(); ++i) { + if (typeid(key) == i->second->key() + && i->first != *node_id) { + if (first) out << " ["; + else out << ", "; + first = false; + + out << i->first << "=\"" << i->second->get_string(key) << "\""; + } + } + + if (!first) out << "]"; + } + + private: + const dynamic_properties* dp; + const std::string* node_id; + }; + + namespace graph { namespace detail { + + template + struct node_id_property_map + { + typedef std::string value_type; + typedef value_type reference; + typedef Vertex key_type; + typedef readable_property_map_tag category; + + node_id_property_map() {} + + node_id_property_map(const dynamic_properties& dp, + const std::string& node_id) + : dp(&dp), node_id(&node_id) { } + + const dynamic_properties* dp; + const std::string* node_id; + }; + + template + inline std::string + get(node_id_property_map pm, + typename node_id_property_map::key_type v) + { return get(*pm.node_id, *pm.dp, v); } + + } } // end namespace graph::detail + + template + inline void + write_graphviz(std::ostream& out, const Graph& g, + const dynamic_properties& dp, + const std::string& node_id = "node_id") + { + typedef typename graph_traits::vertex_descriptor Vertex; + write_graphviz(out, g, dp, node_id, + graph::detail::node_id_property_map(dp, node_id)); + } + + template + void + write_graphviz(std::ostream& out, const Graph& g, + const dynamic_properties& dp, const std::string& node_id, + VertexID id) + { + write_graphviz + (out, g, + /*vertex_writer=*/dynamic_vertex_properties_writer(dp, node_id), + /*edge_writer=*/dynamic_properties_writer(dp), + /*graph_writer=*/default_writer(), + id); + } + +///////////////////////////////////////////////////////////////////////////// +// Graph reader exceptions +///////////////////////////////////////////////////////////////////////////// +struct graph_exception : public std::exception { + virtual ~graph_exception() throw() {} + virtual const char* what() const throw() = 0; +}; + +struct bad_parallel_edge : public graph_exception { + std::string from; + std::string to; + mutable std::string statement; + bad_parallel_edge(const std::string& i, const std::string& j) : + from(i), to(j) {} + + virtual ~bad_parallel_edge() throw() {} + const char* what() const throw() { + if(statement.empty()) + statement = + std::string("Failed to add parallel edge: (") + + from + "," + to + ")\n"; + + return statement.c_str(); + } +}; + +struct directed_graph_error : public graph_exception { + virtual ~directed_graph_error() throw() {} + virtual const char* what() const throw() { + return + "read_graphviz: " + "Tried to read a directed graph into an undirected graph."; + } +}; + +struct undirected_graph_error : public graph_exception { + virtual ~undirected_graph_error() throw() {} + virtual const char* what() const throw() { + return + "read_graphviz: " + "Tried to read an undirected graph into a directed graph."; + } +}; + +namespace detail { namespace graph { + +typedef std::string id_t; +typedef id_t node_t; + +// edges are not uniquely determined by adjacent nodes +class edge_t { + int idx_; + explicit edge_t(int i) : idx_(i) {} +public: + static edge_t new_edge() { + static int idx = 0; + return edge_t(idx++); + }; + + bool operator==(const edge_t& rhs) const { + return idx_ == rhs.idx_; + } + bool operator<(const edge_t& rhs) const { + return idx_ < rhs.idx_; + } +}; + +class mutate_graph +{ + public: + virtual ~mutate_graph() {} + virtual bool is_directed() const = 0; + virtual void do_add_vertex(const node_t& node) = 0; + + virtual void + do_add_edge(const edge_t& edge, const node_t& source, const node_t& target) + = 0; + + virtual void + set_node_property(const id_t& key, const node_t& node, const id_t& value) = 0; + + virtual void + set_edge_property(const id_t& key, const edge_t& edge, const id_t& value) = 0; +}; + +template +class mutate_graph_impl : public mutate_graph +{ + typedef typename graph_traits::vertex_descriptor bgl_vertex_t; + typedef typename graph_traits::edge_descriptor bgl_edge_t; + + public: + mutate_graph_impl(MutableGraph& graph, dynamic_properties& dp, + std::string node_id_prop) + : graph_(graph), dp_(dp), node_id_prop_(node_id_prop) { } + + ~mutate_graph_impl() {} + + bool is_directed() const + { + return + boost::is_convertible< + typename boost::graph_traits::directed_category, + boost::directed_tag>::value; + } + + virtual void do_add_vertex(const node_t& node) + { + // Add the node to the graph. + bgl_vertex_t v = add_vertex(graph_); + + // Set up a mapping from name to BGL vertex. + bgl_nodes.insert(std::make_pair(node, v)); + + // node_id_prop_ allows the caller to see the real id names for nodes. + put(node_id_prop_, dp_, v, node); + } + + void + do_add_edge(const edge_t& edge, const node_t& source, const node_t& target) + { + std::pair result = + add_edge(bgl_nodes[source], bgl_nodes[target], graph_); + + if(!result.second) { + // In the case of no parallel edges allowed + throw bad_parallel_edge(source, target); + } else { + bgl_edges.insert(std::make_pair(edge, result.first)); + } + } + + void + set_node_property(const id_t& key, const node_t& node, const id_t& value) + { + put(key, dp_, bgl_nodes[node], value); + } + + void + set_edge_property(const id_t& key, const edge_t& edge, const id_t& value) + { + put(key, dp_, bgl_edges[edge], value); + } + + protected: + MutableGraph& graph_; + dynamic_properties& dp_; + std::string node_id_prop_; + std::map bgl_nodes; + std::map bgl_edges; +}; + +bool read_graphviz(std::istream& in, mutate_graph& graph); + +} } // end namespace detail::graph + +// Parse the passed stream as a GraphViz dot file. +template +bool read_graphviz(std::istream& in, MutableGraph& graph, + dynamic_properties& dp, + std::string const& node_id = "node_id") +{ + detail::graph::mutate_graph_impl m_graph(graph, dp, node_id); + return detail::graph::read_graphviz(in, m_graph); +} + +} // namespace boost + +#ifdef BOOST_GRAPH_READ_GRAPHVIZ_ITERATORS +# include +#endif // BOOST_GRAPH_READ_GRAPHVIZ_ITERATORS + +#endif // BOOST_GRAPHVIZ_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/gursoy_atun_layout.hpp b/deal.II/contrib/boost/include/boost/graph/gursoy_atun_layout.hpp new file mode 100644 index 0000000000..fb82cb720c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/gursoy_atun_layout.hpp @@ -0,0 +1,631 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Jeremiah Willcock +// Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_GURSOY_ATUN_LAYOUT_HPP +#define BOOST_GRAPH_GURSOY_ATUN_LAYOUT_HPP + +// Gursoy-Atun graph layout, based on: +// "Neighbourhood Preserving Load Balancing: A Self-Organizing Approach" +// in EuroPar 2000, p. 234 of LNCS 1900 +// http://springerlink.metapress.com/link.asp?id=pcu07ew5rhexp9yt + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + +namespace detail { + +struct over_distance_limit : public std::exception {}; + +template +struct update_position_visitor { + typedef typename Topology::point_type Point; + PositionMap position_map; + NodeDistanceMap node_distance; + const Topology& space; + Point input_vector; + double distance_limit; + double learning_constant; + double falloff_ratio; + + typedef boost::on_examine_vertex event_filter; + + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + + update_position_visitor(PositionMap position_map, + NodeDistanceMap node_distance, + const Topology& space, + const Point& input_vector, + double distance_limit, + double learning_constant, + double falloff_ratio): + position_map(position_map), node_distance(node_distance), + space(space), + input_vector(input_vector), distance_limit(distance_limit), + learning_constant(learning_constant), falloff_ratio(falloff_ratio) {} + + void operator()(vertex_descriptor v, const Graph&) const + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::pow; +#endif + + if (get(node_distance, v) > distance_limit) + throw over_distance_limit(); + Point old_position = get(position_map, v); + double distance = get(node_distance, v); + double fraction = + learning_constant * pow(falloff_ratio, distance * distance); + put(position_map, v, + space.move_position_toward(old_position, fraction, input_vector)); + } +}; + +template +struct gursoy_shortest +{ + template + static inline void + run(const Graph& g, typename graph_traits::vertex_descriptor s, + NodeDistanceMap node_distance, UpdatePosition& update_position, + EdgeWeightMap weight) + { + boost::dijkstra_shortest_paths(g, s, weight_map(weight). + visitor(boost::make_dijkstra_visitor(std::make_pair( + boost::record_distances(node_distance, boost::on_edge_relaxed()), + update_position)))); + } +}; + +template<> +struct gursoy_shortest +{ + template + static inline void + run(const Graph& g, typename graph_traits::vertex_descriptor s, + NodeDistanceMap node_distance, UpdatePosition& update_position, + dummy_property_map) + { + boost::breadth_first_search(g, s, + visitor(boost::make_bfs_visitor(std::make_pair( + boost::record_distances(node_distance, boost::on_tree_edge()), + update_position)))); + } +}; + +} // namespace detail + +template +void +gursoy_atun_step + (const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + Diameter diameter, + double learning_constant, + VertexIndexMap vertex_index_map, + EdgeWeightMap weight) +{ +#ifndef BOOST_NO_STDC_NAMESPACE + using std::pow; + using std::exp; +#endif + + typedef typename graph_traits::vertex_iterator + vertex_iterator; + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + typedef typename Topology::point_type point_type; + vertex_iterator i, iend; + std::vector distance_from_input_vector(num_vertices(graph)); + typedef boost::iterator_property_map::iterator, + VertexIndexMap, + double, double&> + DistanceFromInputMap; + DistanceFromInputMap distance_from_input(distance_from_input_vector.begin(), + vertex_index_map); + std::vector node_distance_map_vector(num_vertices(graph)); + typedef boost::iterator_property_map::iterator, + VertexIndexMap, + double, double&> + NodeDistanceMap; + NodeDistanceMap node_distance(node_distance_map_vector.begin(), + vertex_index_map); + point_type input_vector = space.random_point(); + vertex_descriptor min_distance_loc + = graph_traits::null_vertex(); + double min_distance = 0.0; + bool min_distance_unset = true; + for (boost::tie(i, iend) = vertices(graph); i != iend; ++i) { + double this_distance = space.distance(get(position, *i), input_vector); + put(distance_from_input, *i, this_distance); + if (min_distance_unset || this_distance < min_distance) { + min_distance = this_distance; + min_distance_loc = *i; + } + min_distance_unset = false; + } + assert (!min_distance_unset); // Graph must have at least one vertex + boost::detail::update_position_visitor< + PositionMap, NodeDistanceMap, Topology, + VertexListAndIncidenceGraph> + update_position(position, node_distance, space, + input_vector, diameter, learning_constant, + exp(-1. / (2 * diameter * diameter))); + std::fill(node_distance_map_vector.begin(), node_distance_map_vector.end(), 0); + try { + typedef detail::gursoy_shortest shortest; + shortest::run(graph, min_distance_loc, node_distance, update_position, + weight); + } catch (detail::over_distance_limit) { + /* Thrown to break out of BFS or Dijkstra early */ + } +} + +template +void gursoy_atun_refine(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + int nsteps, + double diameter_initial, + double diameter_final, + double learning_constant_initial, + double learning_constant_final, + VertexIndexMap vertex_index_map, + EdgeWeightMap weight) +{ +#ifndef BOOST_NO_STDC_NAMESPACE + using std::pow; + using std::exp; +#endif + + typedef typename graph_traits::vertex_iterator + vertex_iterator; + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + typedef typename Topology::point_type point_type; + vertex_iterator i, iend; + double diameter_ratio = (double)diameter_final / diameter_initial; + double learning_constant_ratio = + learning_constant_final / learning_constant_initial; + std::vector distance_from_input_vector(num_vertices(graph)); + typedef boost::iterator_property_map::iterator, + VertexIndexMap, + double, double&> + DistanceFromInputMap; + DistanceFromInputMap distance_from_input(distance_from_input_vector.begin(), + vertex_index_map); + std::vector node_distance_map_vector(num_vertices(graph)); + typedef boost::iterator_property_map::iterator, + VertexIndexMap, double, double&> + NodeDistanceMap; + NodeDistanceMap node_distance(node_distance_map_vector.begin(), + vertex_index_map); + for (int round = 0; round < nsteps; ++round) { + double part_done = (double)round / (nsteps - 1); + int diameter = (int)(diameter_initial * pow(diameter_ratio, part_done)); + double learning_constant = + learning_constant_initial * pow(learning_constant_ratio, part_done); + gursoy_atun_step(graph, space, position, diameter, learning_constant, + vertex_index_map, weight); + } +} + +template +void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + int nsteps, + double diameter_initial, + double diameter_final, + double learning_constant_initial, + double learning_constant_final, + VertexIndexMap vertex_index_map, + EdgeWeightMap weight) +{ + typedef typename graph_traits::vertex_iterator + vertex_iterator; + vertex_iterator i, iend; + for (boost::tie(i, iend) = vertices(graph); i != iend; ++i) { + put(position, *i, space.random_point()); + } + gursoy_atun_refine(graph, space, + position, nsteps, + diameter_initial, diameter_final, + learning_constant_initial, learning_constant_final, + vertex_index_map, weight); +} + +template +void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + int nsteps, + double diameter_initial, + double diameter_final, + double learning_constant_initial, + double learning_constant_final, + VertexIndexMap vertex_index_map) +{ + gursoy_atun_layout(graph, space, position, nsteps, + diameter_initial, diameter_final, + learning_constant_initial, learning_constant_final, + vertex_index_map, dummy_property_map()); +} + +template +void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + int nsteps, + double diameter_initial, + double diameter_final = 1.0, + double learning_constant_initial = 0.8, + double learning_constant_final = 0.2) +{ + gursoy_atun_layout(graph, space, position, nsteps, diameter_initial, + diameter_final, learning_constant_initial, + learning_constant_final, get(vertex_index, graph)); +} + +template +void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + int nsteps) +{ +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif + + gursoy_atun_layout(graph, space, position, nsteps, + sqrt((double)num_vertices(graph))); +} + +template +void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position) +{ + gursoy_atun_layout(graph, space, position, num_vertices(graph)); +} + +template +void +gursoy_atun_layout(const VertexListAndIncidenceGraph& graph, + const Topology& space, + PositionMap position, + const bgl_named_params& params) +{ +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif + + std::pair diam(sqrt(double(num_vertices(graph))), 1.0); + std::pair learn(0.8, 0.2); + gursoy_atun_layout(graph, space, position, + choose_param(get_param(params, iterations_t()), + num_vertices(graph)), + choose_param(get_param(params, diameter_range_t()), + diam).first, + choose_param(get_param(params, diameter_range_t()), + diam).second, + choose_param(get_param(params, learning_constant_range_t()), + learn).first, + choose_param(get_param(params, learning_constant_range_t()), + learn).second, + choose_const_pmap(get_param(params, vertex_index), graph, + vertex_index), + choose_param(get_param(params, edge_weight), + dummy_property_map())); +} + +/*********************************************************** + * Topologies * + ***********************************************************/ +template +class convex_topology +{ + struct point + { + point() { } + double& operator[](std::size_t i) {return values[i];} + const double& operator[](std::size_t i) const {return values[i];} + + private: + double values[Dims]; + }; + + public: + typedef point point_type; + + double distance(point a, point b) const + { + double dist = 0; + for (std::size_t i = 0; i < Dims; ++i) { + double diff = b[i] - a[i]; + dist += diff * diff; + } + // Exact properties of the distance are not important, as long as + // < on what this returns matches real distances + return dist; + } + + point move_position_toward(point a, double fraction, point b) const + { + point result; + for (std::size_t i = 0; i < Dims; ++i) + result[i] = a[i] + (b[i] - a[i]) * fraction; + return result; + } +}; + +template +class hypercube_topology : public convex_topology +{ + typedef uniform_01 rand_t; + + public: + typedef typename convex_topology::point_type point_type; + + explicit hypercube_topology(double scaling = 1.0) + : gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)), + scaling(scaling) + { } + + hypercube_topology(RandomNumberGenerator& gen, double scaling = 1.0) + : gen_ptr(), rand(new rand_t(gen)), scaling(scaling) { } + + point_type random_point() const + { + point_type p; + for (std::size_t i = 0; i < Dims; ++i) + p[i] = (*rand)() * scaling; + return p; + } + + private: + shared_ptr gen_ptr; + shared_ptr rand; + double scaling; +}; + +template +class square_topology : public hypercube_topology<2, RandomNumberGenerator> +{ + typedef hypercube_topology<2, RandomNumberGenerator> inherited; + + public: + explicit square_topology(double scaling = 1.0) : inherited(scaling) { } + + square_topology(RandomNumberGenerator& gen, double scaling = 1.0) + : inherited(gen, scaling) { } +}; + +template +class cube_topology : public hypercube_topology<3, RandomNumberGenerator> +{ + typedef hypercube_topology<3, RandomNumberGenerator> inherited; + + public: + explicit cube_topology(double scaling = 1.0) : inherited(scaling) { } + + cube_topology(RandomNumberGenerator& gen, double scaling = 1.0) + : inherited(gen, scaling) { } +}; + +template +class ball_topology : public convex_topology +{ + typedef uniform_01 rand_t; + + public: + typedef typename convex_topology::point_type point_type; + + explicit ball_topology(double radius = 1.0) + : gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)), + radius(radius) + { } + + ball_topology(RandomNumberGenerator& gen, double radius = 1.0) + : gen_ptr(), rand(new rand_t(gen)), radius(radius) { } + + point_type random_point() const + { + point_type p; + double dist_sum; + do { + dist_sum = 0.0; + for (std::size_t i = 0; i < Dims; ++i) { + double x = (*rand)() * 2*radius - radius; + p[i] = x; + dist_sum += x * x; + } + } while (dist_sum > radius*radius); + return p; + } + + private: + shared_ptr gen_ptr; + shared_ptr rand; + double radius; +}; + +template +class circle_topology : public ball_topology<2, RandomNumberGenerator> +{ + typedef ball_topology<2, RandomNumberGenerator> inherited; + + public: + explicit circle_topology(double radius = 1.0) : inherited(radius) { } + + circle_topology(RandomNumberGenerator& gen, double radius = 1.0) + : inherited(gen, radius) { } +}; + +template +class sphere_topology : public ball_topology<3, RandomNumberGenerator> +{ + typedef ball_topology<3, RandomNumberGenerator> inherited; + + public: + explicit sphere_topology(double radius = 1.0) : inherited(radius) { } + + sphere_topology(RandomNumberGenerator& gen, double radius = 1.0) + : inherited(gen, radius) { } +}; + +template +class heart_topology +{ + // Heart is defined as the union of three shapes: + // Square w/ corners (+-1000, -1000), (0, 0), (0, -2000) + // Circle centered at (-500, -500) radius 500*sqrt(2) + // Circle centered at (500, -500) radius 500*sqrt(2) + // Bounding box (-1000, -2000) - (1000, 500*(sqrt(2) - 1)) + + struct point + { + point() { values[0] = 0.0; values[1] = 0.0; } + point(double x, double y) { values[0] = x; values[1] = y; } + + double& operator[](std::size_t i) { return values[i]; } + double operator[](std::size_t i) const { return values[i]; } + + private: + double values[2]; + }; + + bool in_heart(point p) const + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::abs; + using std::pow; +#endif + + if (p[1] < abs(p[0]) - 2000) return false; // Bottom + if (p[1] <= -1000) return true; // Diagonal of square + if (pow(p[0] - -500, 2) + pow(p[1] - -500, 2) <= 500000) + return true; // Left circle + if (pow(p[0] - 500, 2) + pow(p[1] - -500, 2) <= 500000) + return true; // Right circle + return false; + } + + bool segment_within_heart(point p1, point p2) const + { + // Assumes that p1 and p2 are within the heart + if ((p1[0] < 0) == (p2[0] < 0)) return true; // Same side of symmetry line + if (p1[0] == p2[0]) return true; // Vertical + double slope = (p2[1] - p1[1]) / (p2[0] - p1[0]); + double intercept = p1[1] - p1[0] * slope; + if (intercept > 0) return false; // Crosses between circles + return true; + } + + typedef uniform_01 rand_t; + + public: + typedef point point_type; + + heart_topology() + : gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)) { } + + heart_topology(RandomNumberGenerator& gen) + : gen_ptr(), rand(new rand_t(gen)) { } + + point random_point() const + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif + + point result; + double sqrt2 = sqrt(2.); + do { + result[0] = (*rand)() * (1000 + 1000 * sqrt2) - (500 + 500 * sqrt2); + result[1] = (*rand)() * (2000 + 500 * (sqrt2 - 1)) - 2000; + } while (!in_heart(result)); + return result; + } + + double distance(point a, point b) const + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif + if (segment_within_heart(a, b)) { + // Straight line + return sqrt((b[0] - a[0]) * (b[0] - a[0]) + (b[1] - a[1]) * (b[1] - a[1])); + } else { + // Straight line bending around (0, 0) + return sqrt(a[0] * a[0] + a[1] * a[1]) + sqrt(b[0] * b[0] + b[1] * b[1]); + } + } + + point move_position_toward(point a, double fraction, point b) const + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif + + if (segment_within_heart(a, b)) { + // Straight line + return point(a[0] + (b[0] - a[0]) * fraction, + a[1] + (b[1] - a[1]) * fraction); + } else { + double distance_to_point_a = sqrt(a[0] * a[0] + a[1] * a[1]); + double distance_to_point_b = sqrt(b[0] * b[0] + b[1] * b[1]); + double location_of_point = distance_to_point_a / + (distance_to_point_a + distance_to_point_b); + if (fraction < location_of_point) + return point(a[0] * (1 - fraction / location_of_point), + a[1] * (1 - fraction / location_of_point)); + else + return point( + b[0] * ((fraction - location_of_point) / (1 - location_of_point)), + b[1] * ((fraction - location_of_point) / (1 - location_of_point))); + } + } + + private: + shared_ptr gen_ptr; + shared_ptr rand; +}; + +} // namespace boost + +#endif // BOOST_GRAPH_GURSOY_ATUN_LAYOUT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/incremental_components.hpp b/deal.II/contrib/boost/include/boost/graph/incremental_components.hpp new file mode 100644 index 0000000000..4cb571bb0b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/incremental_components.hpp @@ -0,0 +1,170 @@ +// +//======================================================================= +// Copyright 1997-2001 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_INCREMENTAL_COMPONENTS_HPP +#define BOOST_INCREMENTAL_COMPONENTS_HPP + +#include +#include + +namespace boost { + + // A connected component algorithm for the case when dynamically + // adding (but not removing) edges is common. The + // incremental_components() function is a preparing operation. Call + // same_component to check whether two vertices are in the same + // component, or use disjoint_set::find_set to determine the + // representative for a vertex. + + // This version of connected components does not require a full + // Graph. Instead, it just needs an edge list, where the vertices of + // each edge need to be of integer type. The edges are assumed to + // be undirected. The other difference is that the result is stored in + // a container, instead of just a decorator. The container should be + // empty before the algorithm is called. It will grow during the + // course of the algorithm. The container must be a model of + // BackInsertionSequence and RandomAccessContainer + // (std::vector is a good choice). After running the algorithm the + // index container will map each vertex to the representative + // vertex of the component to which it belongs. + // + // Adapted from an implementation by Alex Stepanov. The disjoint + // sets data structure is from Tarjan's "Data Structures and Network + // Algorithms", and the application to connected components is + // similar to the algorithm described in Ch. 22 of "Intro to + // Algorithms" by Cormen, et. all. + // + // RankContainer is a random accessable container (operator[] is + // defined) with a value type that can represent an integer part of + // a binary log of the value type of the corresponding + // ParentContainer (char is always enough) its size_type is no less + // than the size_type of the corresponding ParentContainer + + // An implementation of disjoint sets can be found in + // boost/pending/disjoint_sets.hpp + + template + void incremental_components(EdgeListGraph& g, DisjointSets& ds) + { + typename graph_traits::edge_iterator e, end; + for (tie(e,end) = edges(g); e != end; ++e) + ds.union_set(source(*e,g),target(*e,g)); + } + + template + void compress_components(ParentIterator first, ParentIterator last) + { + for (ParentIterator current = first; current != last; ++current) + detail::find_representative_with_full_compression(first, current-first); + } + + template + typename boost::detail::iterator_traits::difference_type + component_count(ParentIterator first, ParentIterator last) + { + std::ptrdiff_t count = 0; + for (ParentIterator current = first; current != last; ++current) + if (*current == current - first) ++count; + return count; + } + + // This algorithm can be applied to the result container of the + // connected_components algorithm to normalize + // the components. + template + void normalize_components(ParentIterator first, ParentIterator last) + { + for (ParentIterator current = first; current != last; ++current) + detail::normalize_node(first, current - first); + } + + template + void initialize_incremental_components(VertexListGraph& G, DisjointSets& ds) + { + typename graph_traits + ::vertex_iterator v, vend; + for (tie(v, vend) = vertices(G); v != vend; ++v) + ds.make_set(*v); + } + + template + inline bool same_component(Vertex u, Vertex v, DisjointSet& ds) + { + return ds.find_set(u) == ds.find_set(v); + } + + // considering changing the so that it initializes with a pair of + // vertex iterators and a parent PA. + + template + class component_index + { + public://protected: (avoid friends for now) + typedef std::vector MyIndexContainer; + MyIndexContainer header; + MyIndexContainer index; + typedef typename MyIndexContainer::size_type SizeT; + typedef typename MyIndexContainer::const_iterator IndexIter; + public: + typedef detail::component_iterator + component_iterator; + class component { + friend class component_index; + protected: + IndexT number; + const component_index* comp_ind_ptr; + component(IndexT i, const component_index* p) + : number(i), comp_ind_ptr(p) {} + public: + typedef component_iterator iterator; + typedef component_iterator const_iterator; + typedef IndexT value_type; + iterator begin() const { + return iterator( comp_ind_ptr->index.begin(), + (comp_ind_ptr->header)[number] ); + } + iterator end() const { + return iterator( comp_ind_ptr->index.begin(), + comp_ind_ptr->index.size() ); + } + }; + typedef SizeT size_type; + typedef component value_type; + +#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + template + component_index(Iterator first, Iterator last) + : index(std::distance(first, last)) + { + std::copy(first, last, index.begin()); + detail::construct_component_index(index, header); + } +#else + template + component_index(Iterator first, Iterator last) + : index(first, last) + { + detail::construct_component_index(index, header); + } +#endif + + component operator[](IndexT i) const { + return component(i, this); + } + SizeT size() const { + return header.size(); + } + + }; + +} // namespace boost + +#endif // BOOST_INCREMENTAL_COMPONENTS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/isomorphism.hpp b/deal.II/contrib/boost/include/boost/graph/isomorphism.hpp new file mode 100644 index 0000000000..50582a49a6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/isomorphism.hpp @@ -0,0 +1,472 @@ +// Copyright (C) 2001 Jeremy Siek, Douglas Gregor, Brian Osman +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. +#ifndef BOOST_GRAPH_ISOMORPHISM_HPP +#define BOOST_GRAPH_ISOMORPHISM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include // for make_indirect_pmap + +#ifndef BOOST_GRAPH_ITERATION_MACROS_HPP +#define BOOST_ISO_INCLUDED_ITER_MACROS // local macro, see bottom of file +#include +#endif + +namespace boost { + + namespace detail { + + template + class isomorphism_algo + { + typedef typename graph_traits::vertex_descriptor vertex1_t; + typedef typename graph_traits::vertex_descriptor vertex2_t; + typedef typename graph_traits::edge_descriptor edge1_t; + typedef typename graph_traits::vertices_size_type size_type; + typedef typename Invariant1::result_type invar1_value; + typedef typename Invariant2::result_type invar2_value; + + const Graph1& G1; + const Graph2& G2; + IsoMapping f; + Invariant1 invariant1; + Invariant2 invariant2; + std::size_t max_invariant; + IndexMap1 index_map1; + IndexMap2 index_map2; + + std::vector dfs_vertices; + typedef typename std::vector::iterator vertex_iter; + std::vector dfs_num_vec; + typedef safe_iterator_property_map::iterator, + IndexMap1 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , int, int& +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + > DFSNumMap; + DFSNumMap dfs_num; + std::vector ordered_edges; + typedef typename std::vector::iterator edge_iter; + + std::vector in_S_vec; + typedef safe_iterator_property_map::iterator, + IndexMap2 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , char, char& +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + > InSMap; + InSMap in_S; + + int num_edges_on_k; + + friend struct compare_multiplicity; + struct compare_multiplicity + { + compare_multiplicity(Invariant1 invariant1, size_type* multiplicity) + : invariant1(invariant1), multiplicity(multiplicity) { } + bool operator()(const vertex1_t& x, const vertex1_t& y) const { + return multiplicity[invariant1(x)] < multiplicity[invariant1(y)]; + } + Invariant1 invariant1; + size_type* multiplicity; + }; + + struct record_dfs_order : default_dfs_visitor + { + record_dfs_order(std::vector& v, std::vector& e) + : vertices(v), edges(e) { } + + void discover_vertex(vertex1_t v, const Graph1&) const { + vertices.push_back(v); + } + void examine_edge(edge1_t e, const Graph1& G1) const { + edges.push_back(e); + } + std::vector& vertices; + std::vector& edges; + }; + + struct edge_cmp { + edge_cmp(const Graph1& G1, DFSNumMap dfs_num) + : G1(G1), dfs_num(dfs_num) { } + bool operator()(const edge1_t& e1, const edge1_t& e2) const { + using namespace std; + int u1 = dfs_num[source(e1,G1)], v1 = dfs_num[target(e1,G1)]; + int u2 = dfs_num[source(e2,G1)], v2 = dfs_num[target(e2,G1)]; + int m1 = (max)(u1, v1); + int m2 = (max)(u2, v2); + // lexicographical comparison + return std::make_pair(m1, std::make_pair(u1, v1)) + < std::make_pair(m2, std::make_pair(u2, v2)); + } + const Graph1& G1; + DFSNumMap dfs_num; + }; + + public: + isomorphism_algo(const Graph1& G1, const Graph2& G2, IsoMapping f, + Invariant1 invariant1, Invariant2 invariant2, std::size_t max_invariant, + IndexMap1 index_map1, IndexMap2 index_map2) + : G1(G1), G2(G2), f(f), invariant1(invariant1), invariant2(invariant2), + max_invariant(max_invariant), + index_map1(index_map1), index_map2(index_map2) + { + in_S_vec.resize(num_vertices(G1)); + in_S = make_safe_iterator_property_map + (in_S_vec.begin(), in_S_vec.size(), index_map2 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , in_S_vec.front() +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + ); + } + + bool test_isomorphism() + { + { + std::vector invar1_array; + BGL_FORALL_VERTICES_T(v, G1, Graph1) + invar1_array.push_back(invariant1(v)); + sort(invar1_array); + + std::vector invar2_array; + BGL_FORALL_VERTICES_T(v, G2, Graph2) + invar2_array.push_back(invariant2(v)); + sort(invar2_array); + if (! equal(invar1_array, invar2_array)) + return false; + } + + std::vector V_mult; + BGL_FORALL_VERTICES_T(v, G1, Graph1) + V_mult.push_back(v); + { + std::vector multiplicity(max_invariant, 0); + BGL_FORALL_VERTICES_T(v, G1, Graph1) + ++multiplicity[invariant1(v)]; + sort(V_mult, compare_multiplicity(invariant1, &multiplicity[0])); + } + + std::vector color_vec(num_vertices(G1)); + safe_iterator_property_map::iterator, + IndexMap1 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , default_color_type, default_color_type& +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + > + color_map(color_vec.begin(), color_vec.size(), index_map1); + record_dfs_order dfs_visitor(dfs_vertices, ordered_edges); + typedef color_traits Color; + for (vertex_iter u = V_mult.begin(); u != V_mult.end(); ++u) { + if (color_map[*u] == Color::white()) { + dfs_visitor.start_vertex(*u, G1); + depth_first_visit(G1, *u, dfs_visitor, color_map); + } + } + // Create the dfs_num array and dfs_num_map + dfs_num_vec.resize(num_vertices(G1)); + dfs_num = make_safe_iterator_property_map(dfs_num_vec.begin(), + dfs_num_vec.size(), + index_map1 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , dfs_num_vec.front() +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + ); + size_type n = 0; + for (vertex_iter v = dfs_vertices.begin(); v != dfs_vertices.end(); ++v) + dfs_num[*v] = n++; + + sort(ordered_edges, edge_cmp(G1, dfs_num)); + + + int dfs_num_k = -1; + return this->match(ordered_edges.begin(), dfs_num_k); + } + + private: + bool match(edge_iter iter, int dfs_num_k) + { + if (iter != ordered_edges.end()) { + vertex1_t i = source(*iter, G1), j = target(*iter, G2); + if (dfs_num[i] > dfs_num_k) { + vertex1_t kp1 = dfs_vertices[dfs_num_k + 1]; + BGL_FORALL_VERTICES_T(u, G2, Graph2) { + if (invariant1(kp1) == invariant2(u) && in_S[u] == false) { + f[kp1] = u; + in_S[u] = true; + num_edges_on_k = 0; + + if (match(iter, dfs_num_k + 1)) +#if 0 + // dwa 2003/7/11 -- this *HAS* to be a bug! + ; +#endif + return true; + + in_S[u] = false; + } + } + + } + else if (dfs_num[j] > dfs_num_k) { + vertex1_t k = dfs_vertices[dfs_num_k]; + num_edges_on_k -= + count_if(adjacent_vertices(f[k], G2), make_indirect_pmap(in_S)); + + for (int jj = 0; jj < dfs_num_k; ++jj) { + vertex1_t j = dfs_vertices[jj]; + num_edges_on_k -= count(adjacent_vertices(f[j], G2), f[k]); + } + + if (num_edges_on_k != 0) + return false; + BGL_FORALL_ADJ_T(f[i], v, G2, Graph2) + if (invariant2(v) == invariant1(j) && in_S[v] == false) { + f[j] = v; + in_S[v] = true; + num_edges_on_k = 1; + BOOST_USING_STD_MAX(); + int next_k = max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num_k, max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num[i], dfs_num[j])); + if (match(next(iter), next_k)) + return true; + in_S[v] = false; + } + + + } + else { + if (contains(adjacent_vertices(f[i], G2), f[j])) { + ++num_edges_on_k; + if (match(next(iter), dfs_num_k)) + return true; + } + + } + } else + return true; + return false; + } + + }; + + + template + void compute_in_degree(const Graph& g, InDegreeMap in_degree_map) + { + BGL_FORALL_VERTICES_T(v, g, Graph) + put(in_degree_map, v, 0); + + BGL_FORALL_VERTICES_T(u, g, Graph) + BGL_FORALL_ADJ_T(u, v, g, Graph) + put(in_degree_map, v, get(in_degree_map, v) + 1); + } + + } // namespace detail + + + template + class degree_vertex_invariant + { + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename graph_traits::degree_size_type size_type; + public: + typedef vertex_t argument_type; + typedef size_type result_type; + + degree_vertex_invariant(const InDegreeMap& in_degree_map, const Graph& g) + : m_in_degree_map(in_degree_map), m_g(g) { } + + size_type operator()(vertex_t v) const { + return (num_vertices(m_g) + 1) * out_degree(v, m_g) + + get(m_in_degree_map, v); + } + // The largest possible vertex invariant number + size_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { + return num_vertices(m_g) * num_vertices(m_g) + num_vertices(m_g); + } + private: + InDegreeMap m_in_degree_map; + const Graph& m_g; + }; + + + template + bool isomorphism(const Graph1& G1, const Graph2& G2, IsoMapping f, + Invariant1 invariant1, Invariant2 invariant2, + std::size_t max_invariant, + IndexMap1 index_map1, IndexMap2 index_map2) + + { + // Graph requirements + function_requires< VertexListGraphConcept >(); + function_requires< EdgeListGraphConcept >(); + function_requires< VertexListGraphConcept >(); + function_requires< BidirectionalGraphConcept >(); + + typedef typename graph_traits::vertex_descriptor vertex1_t; + typedef typename graph_traits::vertex_descriptor vertex2_t; + typedef typename graph_traits::vertices_size_type size_type; + + // Vertex invariant requirement + function_requires< AdaptableUnaryFunctionConcept >(); + function_requires< AdaptableUnaryFunctionConcept >(); + + // Property map requirements + function_requires< ReadWritePropertyMapConcept >(); + typedef typename property_traits::value_type IsoMappingValue; + BOOST_STATIC_ASSERT((is_same::value)); + + function_requires< ReadablePropertyMapConcept >(); + typedef typename property_traits::value_type IndexMap1Value; + BOOST_STATIC_ASSERT((is_convertible::value)); + + function_requires< ReadablePropertyMapConcept >(); + typedef typename property_traits::value_type IndexMap2Value; + BOOST_STATIC_ASSERT((is_convertible::value)); + + if (num_vertices(G1) != num_vertices(G2)) + return false; + if (num_vertices(G1) == 0 && num_vertices(G2) == 0) + return true; + + detail::isomorphism_algo + algo(G1, G2, f, invariant1, invariant2, max_invariant, + index_map1, index_map2); + return algo.test_isomorphism(); + } + + + namespace detail { + + template + bool isomorphism_impl(const Graph1& G1, const Graph2& G2, + IsoMapping f, IndexMap1 index_map1, IndexMap2 index_map2, + const bgl_named_params& params) + { + std::vector in_degree1_vec(num_vertices(G1)); + typedef safe_iterator_property_map::iterator, + IndexMap1 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , std::size_t, std::size_t& +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + > InDeg1; + InDeg1 in_degree1(in_degree1_vec.begin(), in_degree1_vec.size(), index_map1); + compute_in_degree(G1, in_degree1); + + std::vector in_degree2_vec(num_vertices(G2)); + typedef safe_iterator_property_map::iterator, + IndexMap2 +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + , std::size_t, std::size_t& +#endif /* BOOST_NO_STD_ITERATOR_TRAITS */ + > InDeg2; + InDeg2 in_degree2(in_degree2_vec.begin(), in_degree2_vec.size(), index_map2); + compute_in_degree(G2, in_degree2); + + degree_vertex_invariant invariant1(in_degree1, G1); + degree_vertex_invariant invariant2(in_degree2, G2); + + return isomorphism(G1, G2, f, + choose_param(get_param(params, vertex_invariant1_t()), invariant1), + choose_param(get_param(params, vertex_invariant2_t()), invariant2), + choose_param(get_param(params, vertex_max_invariant_t()), (invariant2.max)()), + index_map1, index_map2 + ); + } + + } // namespace detail + + + // Named parameter interface + template + bool isomorphism(const Graph1& g1, + const Graph2& g2, + const bgl_named_params& params) + { + typedef typename graph_traits::vertex_descriptor vertex2_t; + typename std::vector::size_type n = num_vertices(g1); + std::vector f(n); + return detail::isomorphism_impl + (g1, g2, + choose_param(get_param(params, vertex_isomorphism_t()), + make_safe_iterator_property_map(f.begin(), f.size(), + choose_const_pmap(get_param(params, vertex_index1), + g1, vertex_index), vertex2_t())), + choose_const_pmap(get_param(params, vertex_index1), g1, vertex_index), + choose_const_pmap(get_param(params, vertex_index2), g2, vertex_index), + params + ); + } + + // All defaults interface + template + bool isomorphism(const Graph1& g1, const Graph2& g2) + { + return isomorphism(g1, g2, + bgl_named_params(0));// bogus named param + } + + + // Verify that the given mapping iso_map from the vertices of g1 to the + // vertices of g2 describes an isomorphism. + // Note: this could be made much faster by specializing based on the graph + // concepts modeled, but since we're verifying an O(n^(lg n)) algorithm, + // O(n^4) won't hurt us. + template + inline bool verify_isomorphism(const Graph1& g1, const Graph2& g2, IsoMap iso_map) + { +#if 0 + // problematic for filtered_graph! + if (num_vertices(g1) != num_vertices(g2) || num_edges(g1) != num_edges(g2)) + return false; +#endif + + for (typename graph_traits::edge_iterator e1 = edges(g1).first; + e1 != edges(g1).second; ++e1) { + bool found_edge = false; + for (typename graph_traits::edge_iterator e2 = edges(g2).first; + e2 != edges(g2).second && !found_edge; ++e2) { + if (source(*e2, g2) == get(iso_map, source(*e1, g1)) && + target(*e2, g2) == get(iso_map, target(*e1, g1))) { + found_edge = true; + } + } + + if (!found_edge) + return false; + } + + return true; + } + +} // namespace boost + +#ifdef BOOST_ISO_INCLUDED_ITER_MACROS +#undef BOOST_ISO_INCLUDED_ITER_MACROS +#include +#endif + +#endif // BOOST_GRAPH_ISOMORPHISM_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/iteration_macros.hpp b/deal.II/contrib/boost/include/boost/graph/iteration_macros.hpp new file mode 100644 index 0000000000..850e887518 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/iteration_macros.hpp @@ -0,0 +1,129 @@ +//======================================================================= +// Copyright 2001 Indiana University +// Author: Jeremy G. Siek +// +// 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_GRAPH_ITERATION_MACROS_HPP +#define BOOST_GRAPH_ITERATION_MACROS_HPP + +#define BGL_CAT(x,y) x ## y +#define BGL_FIRST(linenum) BGL_CAT(bgl_first_,linenum) +#define BGL_LAST(linenum) BGL_CAT(bgl_last_,linenum) + +/* + BGL_FORALL_VERTICES_T(v, g, graph_t) // This is on line 9 + expands to the following, but all on the same line + + for (typename boost::graph_traits::vertex_iterator + bgl_first_9 = vertices(g).first, bgl_last_9 = vertices(g).second; + bgl_first_9 != bgl_last_9; bgl_first_9 = bgl_last_9) + for (typename boost::graph_traits::vertex_descriptor v; + bgl_first_9 != bgl_last ? (v = *bgl_first_9, true) : false; + ++bgl_first_9) + + The purpose of having two for-loops is just to provide a place to + declare both the iterator and value variables. There is really only + one loop. The stopping condition gets executed two more times than it + usually would be, oh well. The reason for the bgl_first_9 = bgl_last_9 + in the outer for-loop is in case the user puts a break statement + in the inner for-loop. + + The other macros work in a similar fashion. + + Use the _T versions when the graph type is a template parameter or + dependent on a template parameter. Otherwise use the non _T versions. + + */ + + +#define BGL_FORALL_VERTICES_T(VNAME, GNAME, GraphType) \ +for (typename boost::graph_traits::vertex_iterator \ + BGL_FIRST(__LINE__) = vertices(GNAME).first, BGL_LAST(__LINE__) = vertices(GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ + for (typename boost::graph_traits::vertex_descriptor VNAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (VNAME = *BGL_FIRST(__LINE__), true):false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_VERTICES(VNAME, GNAME, GraphType) \ +for (boost::graph_traits::vertex_iterator \ + BGL_FIRST(__LINE__) = vertices(GNAME).first, BGL_LAST(__LINE__) = vertices(GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ + for (boost::graph_traits::vertex_descriptor VNAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (VNAME = *BGL_FIRST(__LINE__), true):false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_EDGES_T(ENAME, GNAME, GraphType) \ +for (typename boost::graph_traits::edge_iterator \ + BGL_FIRST(__LINE__) = edges(GNAME).first, BGL_LAST(__LINE__) = edges(GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ + for (typename boost::graph_traits::edge_descriptor ENAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (ENAME = *BGL_FIRST(__LINE__), true):false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_EDGES(ENAME, GNAME, GraphType) \ +for (boost::graph_traits::edge_iterator \ + BGL_FIRST(__LINE__) = edges(GNAME).first, BGL_LAST(__LINE__) = edges(GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ + for (boost::graph_traits::edge_descriptor ENAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (ENAME = *BGL_FIRST(__LINE__), true):false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_ADJ_T(UNAME, VNAME, GNAME, GraphType) \ +for (typename boost::graph_traits::adjacency_iterator \ + BGL_FIRST(__LINE__) = adjacent_vertices(UNAME, GNAME).first,\ + BGL_LAST(__LINE__) = adjacent_vertices(UNAME, GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ +for (typename boost::graph_traits::vertex_descriptor VNAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (VNAME = *BGL_FIRST(__LINE__), true) : false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_ADJ(UNAME, VNAME, GNAME, GraphType) \ +for (boost::graph_traits::adjacency_iterator \ + BGL_FIRST(__LINE__) = adjacent_vertices(UNAME, GNAME).first,\ + BGL_LAST(__LINE__) = adjacent_vertices(UNAME, GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ +for (boost::graph_traits::vertex_descriptor VNAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (VNAME = *BGL_FIRST(__LINE__), true) : false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_OUTEDGES_T(UNAME, ENAME, GNAME, GraphType) \ +for (typename boost::graph_traits::out_edge_iterator \ + BGL_FIRST(__LINE__) = out_edges(UNAME, GNAME).first,\ + BGL_LAST(__LINE__) = out_edges(UNAME, GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ +for (typename boost::graph_traits::edge_descriptor ENAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (ENAME = *BGL_FIRST(__LINE__), true) : false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_OUTEDGES(UNAME, ENAME, GNAME, GraphType) \ +for (boost::graph_traits::out_edge_iterator \ + BGL_FIRST(__LINE__) = out_edges(UNAME, GNAME).first,\ + BGL_LAST(__LINE__) = out_edges(UNAME, GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ +for (boost::graph_traits::edge_descriptor ENAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (ENAME = *BGL_FIRST(__LINE__), true) : false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_INEDGES_T(UNAME, ENAME, GNAME, GraphType) \ +for (typename boost::graph_traits::in_edge_iterator \ + BGL_FIRST(__LINE__) = in_edges(UNAME, GNAME).first,\ + BGL_LAST(__LINE__) = in_edges(UNAME, GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ +for (typename boost::graph_traits::edge_descriptor ENAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (ENAME = *BGL_FIRST(__LINE__), true) : false; \ + ++BGL_FIRST(__LINE__)) + +#define BGL_FORALL_INEDGES(UNAME, ENAME, GNAME, GraphType) \ +for (boost::graph_traits::in_edge_iterator \ + BGL_FIRST(__LINE__) = in_edges(UNAME, GNAME).first,\ + BGL_LAST(__LINE__) = in_edges(UNAME, GNAME).second; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__); BGL_FIRST(__LINE__) = BGL_LAST(__LINE__)) \ +for (boost::graph_traits::edge_descriptor ENAME; \ + BGL_FIRST(__LINE__) != BGL_LAST(__LINE__) ? (ENAME = *BGL_FIRST(__LINE__), true) : false; \ + ++BGL_FIRST(__LINE__)) + +#endif // BOOST_GRAPH_ITERATION_MACROS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/iteration_macros_undef.hpp b/deal.II/contrib/boost/include/boost/graph/iteration_macros_undef.hpp new file mode 100644 index 0000000000..0b3f4174df --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/iteration_macros_undef.hpp @@ -0,0 +1,22 @@ +//======================================================================= +// Copyright 2002 Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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) +//======================================================================= + +#ifdef BOOST_GRAPH_ITERATION_MACROS_HPP + +#undef BOOST_GRAPH_ITERATION_MACROS_HPP +#undef BGL_CAT +#undef BGL_FIRST +#undef BGL_LAST +#undef BGL_FORALL_VERTICES +#undef BGL_FORALL_EDGES +#undef BGL_FORALL_ADJACENT +#undef BGL_FORALL_OUTEDGES +#undef BGL_FORALL_INEDGES + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/johnson_all_pairs_shortest.hpp b/deal.II/contrib/boost/include/boost/graph/johnson_all_pairs_shortest.hpp new file mode 100644 index 0000000000..ff6344bdcf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/johnson_all_pairs_shortest.hpp @@ -0,0 +1,184 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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) +//======================================================================= + +/* + This file implements the function + + template + bool + johnson_all_pairs_shortest_paths + (VertexAndEdgeListGraph& g, + DistanceMatrix& D, + const bgl_named_params& params) + */ + +#ifndef BOOST_GRAPH_JOHNSON_HPP +#define BOOST_GRAPH_JOHNSON_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + bool + johnson_all_pairs_shortest_paths(VertexAndEdgeListGraph& g1, + DistanceMatrix& D, + VertexID id1, Weight w1, DistanceZero zero) + { + typedef graph_traits Traits1; + typedef typename property_traits::value_type DT; + function_requires< BasicMatrixConcept >(); + + typedef typename Traits1::directed_category DirCat; + bool is_undirected = is_same::value; + + typedef adjacency_list, + property< edge_weight_t, DT, + property< edge_weight2_t, DT > > > Graph2; + typedef graph_traits Traits2; + + Graph2 g2(num_vertices(g1) + 1); + typename property_map::type + w = get(edge_weight, g2); + typename property_map::type + w_hat = get(edge_weight2, g2); + typename property_map::type + d = get(vertex_distance, g2); + typedef typename property_map::type VertexID2; + VertexID2 id2 = get(vertex_index, g2); + + // Construct g2 where V[g2] = V[g1] U {s} + // and E[g2] = E[g1] U {(s,v)| v in V[g1]} + std::vector + verts1(num_vertices(g1) + 1); + typename Traits2::vertex_descriptor s = *vertices(g2).first; + { + typename Traits1::vertex_iterator v, v_end; + int i = 1; + for (tie(v, v_end) = vertices(g1); v != v_end; ++v, ++i) { + typename Traits2::edge_descriptor e; bool z; + tie(e, z) = add_edge(s, get(id1, *v) + 1, g2); + put(w, e, zero); + verts1[i] = *v; + } + typename Traits1::edge_iterator e, e_end; + for (tie(e, e_end) = edges(g1); e != e_end; ++e) { + typename Traits2::edge_descriptor e2; bool z; + tie(e2, z) = add_edge(get(id1, source(*e, g1)) + 1, + get(id1, target(*e, g1)) + 1, g2); + put(w, e2, get(w1, *e)); + if (is_undirected) { + tie(e2, z) = add_edge(get(id1, target(*e, g1)) + 1, + get(id1, source(*e, g1)) + 1, g2); + put(w, e2, get(w1, *e)); + } + } + } + typename Traits2::vertex_iterator v, v_end, u, u_end; + typename Traits2::edge_iterator e, e_end; + std::vector

h_vec(num_vertices(g2)); + typedef typename std::vector
::iterator iter_t; + iterator_property_map h(h_vec.begin(), id2); + + DT inf = (std::numeric_limits
::max)(); + for (tie(v, v_end) = vertices(g2); v != v_end; ++v) + d[*v] = inf; + + put(d, s, zero); + // Using the non-named parameter versions of bellman_ford and + // dijkstra for portability reasons. + dummy_property_map pred; closed_plus
combine; + std::less
compare; bellman_visitor<> bvis; + if (bellman_ford_shortest_paths + (g2, num_vertices(g2), w, pred, d, combine, compare, bvis)) { + for (tie(v, v_end) = vertices(g2); v != v_end; ++v) + put(h, *v, get(d, *v)); + // Reweight the edges to remove negatives + for (tie(e, e_end) = edges(g2); e != e_end; ++e) { + typename Traits2::vertex_descriptor a = source(*e, g2), + b = target(*e, g2); + put(w_hat, *e, get(w, *e) + get(h, a) - get(h, b)); + } + for (tie(u, u_end) = vertices(g2); u != u_end; ++u) { + dijkstra_visitor<> dvis; + dijkstra_shortest_paths + (g2, *u, pred, d, w_hat, id2, compare, combine, inf, zero,dvis); + for (tie(v, v_end) = vertices(g2); v != v_end; ++v) { + if (*u != s && *v != s) { + typename Traits1::vertex_descriptor u1, v1; + u1 = verts1[id2[*u]]; v1 = verts1[id2[*v]]; + D[id2[*u]-1][id2[*v]-1] = get(d, *v) + get(h, *v) - get(h, *u); + } + } + } + return true; + } else + return false; + } + + namespace detail { + + template + bool + johnson_dispatch(VertexAndEdgeListGraph& g, + DistanceMatrix& D, + const bgl_named_params& params, + Weight w, VertexID id) + { + typedef typename property_traits::value_type WT; + + return johnson_all_pairs_shortest_paths + (g, D, id, w, + choose_param(get_param(params, distance_zero_t()), WT()) ); + } + + } // namespace detail + + template + bool + johnson_all_pairs_shortest_paths + (VertexAndEdgeListGraph& g, + DistanceMatrix& D, + const bgl_named_params& params) + { + return detail::johnson_dispatch + (g, D, params, + choose_const_pmap(get_param(params, edge_weight), g, edge_weight), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index) + ); + } + + template + bool + johnson_all_pairs_shortest_paths + (VertexAndEdgeListGraph& g, DistanceMatrix& D) + { + bgl_named_params params(1); + return detail::johnson_dispatch + (g, D, params, get(edge_weight, g), get(vertex_index, g)); + } + +} // namespace boost + +#endif // BOOST_GRAPH_JOHNSON_HPP + + diff --git a/deal.II/contrib/boost/include/boost/graph/kamada_kawai_spring_layout.hpp b/deal.II/contrib/boost/include/boost/graph/kamada_kawai_spring_layout.hpp new file mode 100644 index 0000000000..884cb0369f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/kamada_kawai_spring_layout.hpp @@ -0,0 +1,542 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_KAMADA_KAWAI_SPRING_LAYOUT_HPP +#define BOOST_GRAPH_KAMADA_KAWAI_SPRING_LAYOUT_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + namespace detail { namespace graph { + /** + * Denotes an edge or display area side length used to scale a + * Kamada-Kawai drawing. + */ + template + struct edge_or_side + { + explicit edge_or_side(T value) : value(value) {} + + T value; + }; + + /** + * Compute the edge length from an edge length. This is trivial. + */ + template + T compute_edge_length(const Graph&, DistanceMap, IndexMap, + edge_or_side length) + { return length.value; } + + /** + * Compute the edge length based on the display area side + length. We do this by dividing the side length by the largest + shortest distance between any two vertices in the graph. + */ + template + T + compute_edge_length(const Graph& g, DistanceMap distance, IndexMap index, + edge_or_side length) + { + T result(0); + + typedef typename graph_traits::vertex_iterator vertex_iterator; + + for (vertex_iterator ui = vertices(g).first, end = vertices(g).second; + ui != end; ++ui) { + vertex_iterator vi = ui; + for (++vi; vi != end; ++vi) { + T dij = distance[get(index, *ui)][get(index, *vi)]; + if (dij > result) result = dij; + } + } + return length.value / result; + } + + /** + * Implementation of the Kamada-Kawai spring layout algorithm. + */ + template + struct kamada_kawai_spring_layout_impl + { + typedef typename property_traits::value_type weight_type; + typedef std::pair deriv_type; + typedef typename graph_traits::vertex_iterator vertex_iterator; + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + + kamada_kawai_spring_layout_impl( + const Graph& g, + PositionMap position, + WeightMap weight, + EdgeOrSideLength edge_or_side_length, + Done done, + weight_type spring_constant, + VertexIndexMap index, + DistanceMatrix distance, + SpringStrengthMatrix spring_strength, + PartialDerivativeMap partial_derivatives) + : g(g), position(position), weight(weight), + edge_or_side_length(edge_or_side_length), done(done), + spring_constant(spring_constant), index(index), distance(distance), + spring_strength(spring_strength), + partial_derivatives(partial_derivatives) {} + + // Compute contribution of vertex i to the first partial + // derivatives (dE/dx_m, dE/dy_m) (for vertex m) + deriv_type + compute_partial_derivative(vertex_descriptor m, vertex_descriptor i) + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif // BOOST_NO_STDC_NAMESPACE + + deriv_type result(0, 0); + if (i != m) { + weight_type x_diff = position[m].x - position[i].x; + weight_type y_diff = position[m].y - position[i].y; + weight_type dist = sqrt(x_diff * x_diff + y_diff * y_diff); + result.first = spring_strength[get(index, m)][get(index, i)] + * (x_diff - distance[get(index, m)][get(index, i)]*x_diff/dist); + result.second = spring_strength[get(index, m)][get(index, i)] + * (y_diff - distance[get(index, m)][get(index, i)]*y_diff/dist); + } + + return result; + } + + // Compute partial derivatives dE/dx_m and dE/dy_m + deriv_type + compute_partial_derivatives(vertex_descriptor m) + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif // BOOST_NO_STDC_NAMESPACE + + deriv_type result(0, 0); + + // TBD: looks like an accumulate to me + std::pair verts = vertices(g); + for (/* no init */; verts.first != verts.second; ++verts.first) { + vertex_descriptor i = *verts.first; + deriv_type deriv = compute_partial_derivative(m, i); + result.first += deriv.first; + result.second += deriv.second; + } + + return result; + } + + // The actual Kamada-Kawai spring layout algorithm implementation + bool run() + { +#ifndef BOOST_NO_STDC_NAMESPACE + using std::sqrt; +#endif // BOOST_NO_STDC_NAMESPACE + + // Compute d_{ij} and place it in the distance matrix + if (!johnson_all_pairs_shortest_paths(g, distance, index, weight, + weight_type(0))) + return false; + + // Compute L based on side length (if needed), or retrieve L + weight_type edge_length = + detail::graph::compute_edge_length(g, distance, index, + edge_or_side_length); + + // Compute l_{ij} and k_{ij} + const weight_type K = spring_constant; + vertex_iterator ui, end = vertices(g).second; + for (ui = vertices(g).first; ui != end; ++ui) { + vertex_iterator vi = ui; + for (++vi; vi != end; ++vi) { + weight_type dij = distance[get(index, *ui)][get(index, *vi)]; + if (dij == (std::numeric_limits::max)()) + return false; + distance[get(index, *ui)][get(index, *vi)] = edge_length * dij; + distance[get(index, *vi)][get(index, *ui)] = edge_length * dij; + spring_strength[get(index, *ui)][get(index, *vi)] = K/(dij*dij); + spring_strength[get(index, *vi)][get(index, *ui)] = K/(dij*dij); + } + } + + // Compute Delta_i and find max + vertex_descriptor p = *vertices(g).first; + weight_type delta_p(0); + + for (ui = vertices(g).first; ui != end; ++ui) { + deriv_type deriv = compute_partial_derivatives(*ui); + put(partial_derivatives, *ui, deriv); + + weight_type delta = + sqrt(deriv.first*deriv.first + deriv.second*deriv.second); + + if (delta > delta_p) { + p = *ui; + delta_p = delta; + } + } + + while (!done(delta_p, p, g, true)) { + // The contribution p makes to the partial derivatives of + // each vertex. Computing this (at O(n) cost) allows us to + // update the delta_i values in O(n) time instead of O(n^2) + // time. + std::vector p_partials(num_vertices(g)); + for (ui = vertices(g).first; ui != end; ++ui) { + vertex_descriptor i = *ui; + p_partials[get(index, i)] = compute_partial_derivative(i, p); + } + + do { + // Compute the 4 elements of the Jacobian + weight_type dE_dx_dx = 0, dE_dx_dy = 0, dE_dy_dx = 0, dE_dy_dy = 0; + for (ui = vertices(g).first; ui != end; ++ui) { + vertex_descriptor i = *ui; + if (i != p) { + weight_type x_diff = position[p].x - position[i].x; + weight_type y_diff = position[p].y - position[i].y; + weight_type dist = sqrt(x_diff * x_diff + y_diff * y_diff); + weight_type dist_cubed = dist * dist * dist; + weight_type k_mi = spring_strength[get(index,p)][get(index,i)]; + weight_type l_mi = distance[get(index, p)][get(index, i)]; + dE_dx_dx += k_mi * (1 - (l_mi * y_diff * y_diff)/dist_cubed); + dE_dx_dy += k_mi * l_mi * x_diff * y_diff / dist_cubed; + dE_dy_dx += k_mi * l_mi * x_diff * y_diff / dist_cubed; + dE_dy_dy += k_mi * (1 - (l_mi * x_diff * x_diff)/dist_cubed); + } + } + + // Solve for delta_x and delta_y + weight_type dE_dx = get(partial_derivatives, p).first; + weight_type dE_dy = get(partial_derivatives, p).second; + + weight_type delta_x = + (dE_dx_dy * dE_dy - dE_dy_dy * dE_dx) + / (dE_dx_dx * dE_dy_dy - dE_dx_dy * dE_dy_dx); + + weight_type delta_y = + (dE_dx_dx * dE_dy - dE_dy_dx * dE_dx) + / (dE_dy_dx * dE_dx_dy - dE_dx_dx * dE_dy_dy); + + + // Move p by (delta_x, delta_y) + position[p].x += delta_x; + position[p].y += delta_y; + + // Recompute partial derivatives and delta_p + deriv_type deriv = compute_partial_derivatives(p); + put(partial_derivatives, p, deriv); + + delta_p = + sqrt(deriv.first*deriv.first + deriv.second*deriv.second); + } while (!done(delta_p, p, g, false)); + + // Select new p by updating each partial derivative and delta + vertex_descriptor old_p = p; + for (ui = vertices(g).first; ui != end; ++ui) { + deriv_type old_deriv_p = p_partials[get(index, *ui)]; + deriv_type old_p_partial = + compute_partial_derivative(*ui, old_p); + deriv_type deriv = get(partial_derivatives, *ui); + + deriv.first += old_p_partial.first - old_deriv_p.first; + deriv.second += old_p_partial.second - old_deriv_p.second; + + put(partial_derivatives, *ui, deriv); + weight_type delta = + sqrt(deriv.first*deriv.first + deriv.second*deriv.second); + + if (delta > delta_p) { + p = *ui; + delta_p = delta; + } + } + } + + return true; + } + + const Graph& g; + PositionMap position; + WeightMap weight; + EdgeOrSideLength edge_or_side_length; + Done done; + weight_type spring_constant; + VertexIndexMap index; + DistanceMatrix distance; + SpringStrengthMatrix spring_strength; + PartialDerivativeMap partial_derivatives; + }; + } } // end namespace detail::graph + + /// States that the given quantity is an edge length. + template + inline detail::graph::edge_or_side + edge_length(T x) + { return detail::graph::edge_or_side(x); } + + /// States that the given quantity is a display area side length. + template + inline detail::graph::edge_or_side + side_length(T x) + { return detail::graph::edge_or_side(x); } + + /** + * \brief Determines when to terminate layout of a particular graph based + * on a given relative tolerance. + */ + template + struct layout_tolerance + { + layout_tolerance(const T& tolerance = T(0.001)) + : tolerance(tolerance), last_energy((std::numeric_limits::max)()), + last_local_energy((std::numeric_limits::max)()) { } + + template + bool + operator()(T delta_p, + typename boost::graph_traits::vertex_descriptor p, + const Graph& g, + bool global) + { + if (global) { + if (last_energy == (std::numeric_limits::max)()) { + last_energy = delta_p; + return false; + } + + T diff = last_energy - delta_p; + if (diff < T(0)) diff = -diff; + bool done = (delta_p == T(0) || diff / last_energy < tolerance); + last_energy = delta_p; + return done; + } else { + if (last_local_energy == (std::numeric_limits::max)()) { + last_local_energy = delta_p; + return delta_p == T(0); + } + + T diff = last_local_energy - delta_p; + bool done = (delta_p == T(0) || (diff / last_local_energy) < tolerance); + last_local_energy = delta_p; + return done; + } + } + + private: + T tolerance; + T last_energy; + T last_local_energy; + }; + + /** \brief Kamada-Kawai spring layout for undirected graphs. + * + * This algorithm performs graph layout (in two dimensions) for + * connected, undirected graphs. It operates by relating the layout + * of graphs to a dynamic spring system and minimizing the energy + * within that system. The strength of a spring between two vertices + * is inversely proportional to the square of the shortest distance + * (in graph terms) between those two vertices. Essentially, + * vertices that are closer in the graph-theoretic sense (i.e., by + * following edges) will have stronger springs and will therefore be + * placed closer together. + * + * Prior to invoking this algorithm, it is recommended that the + * vertices be placed along the vertices of a regular n-sided + * polygon. + * + * \param g (IN) must be a model of Vertex List Graph, Edge List + * Graph, and Incidence Graph and must be undirected. + * + * \param position (OUT) must be a model of Lvalue Property Map, + * where the value type is a class containing fields @c x and @c y + * that will be set to the @c x and @c y coordinates of each vertex. + * + * \param weight (IN) must be a model of Readable Property Map, + * which provides the weight of each edge in the graph @p g. + * + * \param edge_or_side_length (IN) provides either the unit length + * @c e of an edge in the layout or the length of a side @c s of the + * display area, and must be either @c boost::edge_length(e) or @c + * boost::side_length(s), respectively. + * + * \param done (IN) is a 4-argument function object that is passed + * the current value of delta_p (i.e., the energy of vertex @p p), + * the vertex @p p, the graph @p g, and a boolean flag indicating + * whether @p delta_p is the maximum energy in the system (when @c + * true) or the energy of the vertex being moved. Defaults to @c + * layout_tolerance instantiated over the value type of the weight + * map. + * + * \param spring_constant (IN) is the constant multiplied by each + * spring's strength. Larger values create systems with more energy + * that can take longer to stabilize; smaller values create systems + * with less energy that stabilize quickly but do not necessarily + * result in pleasing layouts. The default value is 1. + * + * \param index (IN) is a mapping from vertices to index values + * between 0 and @c num_vertices(g). The default is @c + * get(vertex_index,g). + * + * \param distance (UTIL/OUT) will be used to store the distance + * from every vertex to every other vertex, which is computed in the + * first stages of the algorithm. This value's type must be a model + * of BasicMatrix with value type equal to the value type of the + * weight map. The default is a a vector of vectors. + * + * \param spring_strength (UTIL/OUT) will be used to store the + * strength of the spring between every pair of vertices. This + * value's type must be a model of BasicMatrix with value type equal + * to the value type of the weight map. The default is a a vector of + * vectors. + * + * \param partial_derivatives (UTIL) will be used to store the + * partial derivates of each vertex with respect to the @c x and @c + * y coordinates. This must be a Read/Write Property Map whose value + * type is a pair with both types equivalent to the value type of + * the weight map. The default is an iterator property map. + * + * \returns @c true if layout was successful or @c false if a + * negative weight cycle was detected. + */ + template + bool + kamada_kawai_spring_layout( + const Graph& g, + PositionMap position, + WeightMap weight, + detail::graph::edge_or_side edge_or_side_length, + Done done, + typename property_traits::value_type spring_constant, + VertexIndexMap index, + DistanceMatrix distance, + SpringStrengthMatrix spring_strength, + PartialDerivativeMap partial_derivatives) + { + BOOST_STATIC_ASSERT((is_convertible< + typename graph_traits::directed_category*, + undirected_tag* + >::value)); + + detail::graph::kamada_kawai_spring_layout_impl< + Graph, PositionMap, WeightMap, + detail::graph::edge_or_side, Done, VertexIndexMap, + DistanceMatrix, SpringStrengthMatrix, PartialDerivativeMap> + alg(g, position, weight, edge_or_side_length, done, spring_constant, + index, distance, spring_strength, partial_derivatives); + return alg.run(); + } + + /** + * \overload + */ + template + bool + kamada_kawai_spring_layout( + const Graph& g, + PositionMap position, + WeightMap weight, + detail::graph::edge_or_side edge_or_side_length, + Done done, + typename property_traits::value_type spring_constant, + VertexIndexMap index) + { + typedef typename property_traits::value_type weight_type; + + typename graph_traits::vertices_size_type n = num_vertices(g); + typedef std::vector weight_vec; + + std::vector distance(n, weight_vec(n)); + std::vector spring_strength(n, weight_vec(n)); + std::vector > partial_derivatives(n); + + return + kamada_kawai_spring_layout( + g, position, weight, edge_or_side_length, done, spring_constant, index, + distance.begin(), + spring_strength.begin(), + make_iterator_property_map(partial_derivatives.begin(), index, + std::pair())); + } + + /** + * \overload + */ + template + bool + kamada_kawai_spring_layout( + const Graph& g, + PositionMap position, + WeightMap weight, + detail::graph::edge_or_side edge_or_side_length, + Done done, + typename property_traits::value_type spring_constant) + { + return kamada_kawai_spring_layout(g, position, weight, edge_or_side_length, + done, spring_constant, + get(vertex_index, g)); + } + + /** + * \overload + */ + template + bool + kamada_kawai_spring_layout( + const Graph& g, + PositionMap position, + WeightMap weight, + detail::graph::edge_or_side edge_or_side_length, + Done done) + { + typedef typename property_traits::value_type weight_type; + return kamada_kawai_spring_layout(g, position, weight, edge_or_side_length, + done, weight_type(1)); + } + + /** + * \overload + */ + template + bool + kamada_kawai_spring_layout( + const Graph& g, + PositionMap position, + WeightMap weight, + detail::graph::edge_or_side edge_or_side_length) + { + typedef typename property_traits::value_type weight_type; + return kamada_kawai_spring_layout(g, position, weight, edge_or_side_length, + layout_tolerance(), + weight_type(1.0), + get(vertex_index, g)); + } +} // end namespace boost + +#endif // BOOST_GRAPH_KAMADA_KAWAI_SPRING_LAYOUT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/king_ordering.hpp b/deal.II/contrib/boost/include/boost/graph/king_ordering.hpp new file mode 100644 index 0000000000..df14056d7a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/king_ordering.hpp @@ -0,0 +1,337 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// Doug Gregor, D. Kevin McGrath +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// +#ifndef BOOST_GRAPH_KING_HPP +#define BOOST_GRAPH_KING_HPP + +#include +#include + +/* + King Algorithm for matrix reordering +*/ + +namespace boost { + namespace detail { + template + class bfs_king_visitor:public default_bfs_visitor + { + public: + bfs_king_visitor(OutputIterator *iter, Buffer *b, Compare compare, + PseudoDegreeMap deg, std::vector loc, VecMap color, + VertexIndexMap vertices): + permutation(iter), Qptr(b), degree(deg), comp(compare), + Qlocation(loc), colors(color), vertex_map(vertices) { } + + template + void finish_vertex(Vertex, Graph& g) { + typename graph_traits::out_edge_iterator ei, ei_end; + Vertex v, w; + + typedef typename std::deque::iterator iterator; + typedef typename std::deque::reverse_iterator reverse_iterator; + + reverse_iterator rend = Qptr->rend()-index_begin; + reverse_iterator rbegin = Qptr->rbegin(); + + + //heap the vertices already there + std::make_heap(rbegin, rend, boost::bind(comp, _2, _1)); + + int i = 0; + + for(i = index_begin; i != Qptr->size(); ++i){ + colors[get(vertex_map, (*Qptr)[i])] = 1; + Qlocation[get(vertex_map, (*Qptr)[i])] = i; + } + + i = 0; + + for( ; rbegin != rend; rend--){ + percolate_down(i); + w = (*Qptr)[index_begin+i]; + for (tie(ei, ei_end) = out_edges(w, g); ei != ei_end; ++ei) { + v = target(*ei, g); + put(degree, v, get(degree, v) - 1); + + if (colors[get(vertex_map, v)] == 1) { + percolate_up(get(vertex_map, v), i); + } + } + + colors[get(vertex_map, w)] = 0; + i++; + } + } + + template + void examine_vertex(Vertex u, const Graph&) { + + *(*permutation)++ = u; + index_begin = Qptr->size(); + + } + protected: + + + //this function replaces pop_heap, and tracks state information + template + void percolate_down(int offset){ + typedef typename std::deque::reverse_iterator reverse_iterator; + + int heap_last = index_begin + offset; + int heap_first = Qptr->size() - 1; + + //pop_heap functionality: + //swap first, last + std::swap((*Qptr)[heap_last], (*Qptr)[heap_first]); + + //swap in the location queue + std::swap(Qlocation[heap_first], Qlocation[heap_last]); + + //set drifter, children + int drifter = heap_first; + int drifter_heap = Qptr->size() - drifter; + + int right_child_heap = drifter_heap * 2 + 1; + int right_child = Qptr->size() - right_child_heap; + + int left_child_heap = drifter_heap * 2; + int left_child = Qptr->size() - left_child_heap; + + //check that we are staying in the heap + bool valid = (right_child < heap_last) ? false : true; + + //pick smallest child of drifter, and keep in mind there might only be left child + int smallest_child = (valid && get(degree, (*Qptr)[left_child]) > get(degree,(*Qptr)[right_child])) ? + right_child : left_child; + + while(valid && smallest_child < heap_last && comp((*Qptr)[drifter], (*Qptr)[smallest_child])){ + + //if smallest child smaller than drifter, swap them + std::swap((*Qptr)[smallest_child], (*Qptr)[drifter]); + std::swap(Qlocation[drifter], Qlocation[smallest_child]); + + //update the values, run again, as necessary + drifter = smallest_child; + drifter_heap = Qptr->size() - drifter; + + right_child_heap = drifter_heap * 2 + 1; + right_child = Qptr->size() - right_child_heap; + + left_child_heap = drifter_heap * 2; + left_child = Qptr->size() - left_child_heap; + + valid = (right_child < heap_last) ? false : true; + + smallest_child = (valid && get(degree, (*Qptr)[left_child]) > get(degree,(*Qptr)[right_child])) ? + right_child : left_child; + } + + } + + + + // this is like percolate down, but we always compare against the + // parent, as there is only a single choice + template + void percolate_up(int vertex, int offset){ + + int child_location = Qlocation[vertex]; + int heap_child_location = Qptr->size() - child_location; + int heap_parent_location = (int)(heap_child_location/2); + int parent_location = Qptr->size() - heap_parent_location; + + bool valid = (heap_parent_location != 0 && child_location > index_begin + offset && + parent_location < Qptr->size()); + + while(valid && comp((*Qptr)[child_location], (*Qptr)[parent_location])){ + + //swap in the heap + std::swap((*Qptr)[child_location], (*Qptr)[parent_location]); + + //swap in the location queue + std::swap(Qlocation[child_location], Qlocation[parent_location]); + + child_location = parent_location; + heap_child_location = heap_parent_location; + heap_parent_location = (int)(heap_child_location/2); + parent_location = Qptr->size() - heap_parent_location; + valid = (heap_parent_location != 0 && child_location > index_begin + offset); + } + } + + OutputIterator *permutation; + int index_begin; + Buffer *Qptr; + PseudoDegreeMap degree; + Compare comp; + std::vector Qlocation; + VecMap colors; + VertexIndexMap vertex_map; + }; + + + } // namespace detail + + + template + OutputIterator + king_ordering(const Graph& g, + std::deque< typename graph_traits::vertex_descriptor > + vertex_queue, + OutputIterator permutation, + ColorMap color, DegreeMap degree, + VertexIndexMap index_map) + { + typedef typename property_traits::value_type DS; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typedef typename graph_traits::vertex_descriptor Vertex; + typedef iterator_property_map::iterator, VertexIndexMap, DS, DS&> PseudoDegreeMap; + typedef indirect_cmp > Compare; + typedef typename boost::sparse::sparse_ordering_queue queue; + typedef typename detail::bfs_king_visitor, VertexIndexMap > Visitor; + typedef typename graph_traits::vertices_size_type + vertices_size_type; + std::vector pseudo_degree_vec(num_vertices(g)); + PseudoDegreeMap pseudo_degree(pseudo_degree_vec.begin(), index_map); + + typename graph_traits::vertex_iterator ui, ui_end; + queue Q; + // Copy degree to pseudo_degree + // initialize the color map + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui){ + put(pseudo_degree, *ui, get(degree, *ui)); + put(color, *ui, Color::white()); + } + + Compare comp(pseudo_degree); + std::vector colors(num_vertices(g)); + + for(vertices_size_type i = 0; i < num_vertices(g); i++) + colors[i] = 0; + + std::vector loc(num_vertices(g)); + + //create the visitor + Visitor vis(&permutation, &Q, comp, pseudo_degree, loc, colors, index_map); + + while( !vertex_queue.empty() ) { + Vertex s = vertex_queue.front(); + vertex_queue.pop_front(); + + //call BFS with visitor + breadth_first_visit(g, s, Q, vis, color); + } + + return permutation; + } + + + // This is the case where only a single starting vertex is supplied. + template + OutputIterator + king_ordering(const Graph& g, + typename graph_traits::vertex_descriptor s, + OutputIterator permutation, + ColorMap color, DegreeMap degree, VertexIndexMap index_map) + { + + std::deque< typename graph_traits::vertex_descriptor > vertex_queue; + vertex_queue.push_front( s ); + return king_ordering(g, vertex_queue, permutation, color, degree, + index_map); + } + + + template < class Graph, class OutputIterator, + class ColorMap, class DegreeMap, class VertexIndexMap> + OutputIterator + king_ordering(const Graph& G, OutputIterator permutation, + ColorMap color, DegreeMap degree, VertexIndexMap index_map) + { + if (vertices(G).first == vertices(G).second) + return permutation; + + typedef typename boost::graph_traits::vertex_descriptor Vertex; + typedef typename boost::graph_traits::vertex_iterator VerIter; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + std::deque vertex_queue; + + // Mark everything white + BGL_FORALL_VERTICES_T(v, G, Graph) put(color, v, Color::white()); + + // Find one vertex from each connected component + BGL_FORALL_VERTICES_T(v, G, Graph) { + if (get(color, v) == Color::white()) { + depth_first_visit(G, v, dfs_visitor<>(), color); + vertex_queue.push_back(v); + } + } + + // Find starting nodes for all vertices + // TBD: How to do this with a directed graph? + for (typename std::deque::iterator i = vertex_queue.begin(); + i != vertex_queue.end(); ++i) + *i = find_starting_node(G, *i, color, degree); + + return king_ordering(G, vertex_queue, permutation, color, degree, + index_map); + } + + template + OutputIterator + king_ordering(const Graph& G, OutputIterator permutation, + VertexIndexMap index_map) + { + if (vertices(G).first == vertices(G).second) + return permutation; + + typedef out_degree_property_map DegreeMap; + std::vector colors(num_vertices(G)); + return king_ordering(G, permutation, + make_iterator_property_map(&colors[0], index_map, + colors[0]), + make_out_degree_map(G), index_map); + } + + template + inline OutputIterator + king_ordering(const Graph& G, OutputIterator permutation) + { return king_ordering(G, permutation, get(vertex_index, G)); } + +} // namespace boost + + +#endif // BOOST_GRAPH_KING_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/kruskal_min_spanning_tree.hpp b/deal.II/contrib/boost/include/boost/graph/kruskal_min_spanning_tree.hpp new file mode 100644 index 0000000000..77e3e2f143 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/kruskal_min_spanning_tree.hpp @@ -0,0 +1,152 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_MST_KRUSKAL_HPP +#define BOOST_GRAPH_MST_KRUSKAL_HPP + +/* + *Minimum Spanning Tree + * Kruskal Algorithm + * + *Requirement: + * undirected graph + */ + +#include +#include +#include + +#include +#include +#include +#include +#include + + +namespace boost { + + // Kruskal's algorithm for Minimum Spanning Tree + // + // This is a greedy algorithm to calculate the Minimum Spanning Tree + // for an undirected graph with weighted edges. The output will be a + // set of edges. + // + + namespace detail { + + template + void + kruskal_mst_impl(const Graph& G, + OutputIterator spanning_tree_edges, + Rank rank, Parent parent, Weight weight) + { + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename graph_traits::edge_descriptor Edge; + function_requires >(); + function_requires >(); + function_requires >(); + function_requires >(); + function_requires >(); + function_requires >(); + typedef typename property_traits::value_type W_value; + typedef typename property_traits::value_type R_value; + typedef typename property_traits::value_type P_value; + function_requires >(); + function_requires >(); + function_requires >(); + + disjoint_sets dset(rank, parent); + + typename graph_traits::vertex_iterator ui, uiend; + for (boost::tie(ui, uiend) = vertices(G); ui != uiend; ++ui) + dset.make_set(*ui); + + typedef indirect_cmp > weight_greater; + weight_greater wl(weight); + std::priority_queue, weight_greater> Q(wl); + /*push all edge into Q*/ + typename graph_traits::edge_iterator ei, eiend; + for (boost::tie(ei, eiend) = edges(G); ei != eiend; ++ei) + Q.push(*ei); + + while (! Q.empty()) { + Edge e = Q.top(); + Q.pop(); + Vertex u = dset.find_set(source(e, G)); + Vertex v = dset.find_set(target(e, G)); + if ( u != v ) { + *spanning_tree_edges++ = e; + dset.link(u, v); + } + } + } + + } // namespace detail + + // Named Parameters Variants + + template + inline void + kruskal_minimum_spanning_tree(const Graph& g, + OutputIterator spanning_tree_edges) + { + typedef typename graph_traits::vertices_size_type size_type; + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename property_map::type index_map_t; + typename graph_traits::vertices_size_type + n = num_vertices(g); + std::vector rank_map(n); + std::vector pred_map(n); + + detail::kruskal_mst_impl + (g, spanning_tree_edges, + make_iterator_property_map(rank_map.begin(), get(vertex_index, g), rank_map[0]), + make_iterator_property_map(pred_map.begin(), get(vertex_index, g), pred_map[0]), + get(edge_weight, g)); + } + + template + inline void + kruskal_minimum_spanning_tree(const Graph& g, + OutputIterator spanning_tree_edges, + const bgl_named_params& params) + { + typedef typename graph_traits::vertices_size_type size_type; + typedef typename graph_traits::vertex_descriptor vertex_t; + typename graph_traits::vertices_size_type n; + n = is_default_param(get_param(params, vertex_rank)) + ? num_vertices(g) : 1; + std::vector rank_map(n); + n = is_default_param(get_param(params, vertex_predecessor)) + ? num_vertices(g) : 1; + std::vector pred_map(n); + + detail::kruskal_mst_impl + (g, spanning_tree_edges, + choose_param + (get_param(params, vertex_rank), + make_iterator_property_map + (rank_map.begin(), + choose_pmap(get_param(params, vertex_index), g, vertex_index), rank_map[0])), + choose_param + (get_param(params, vertex_predecessor), + make_iterator_property_map + (pred_map.begin(), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index), + pred_map[0])), + choose_const_pmap(get_param(params, edge_weight), g, edge_weight)); + } + +} // namespace boost + + +#endif // BOOST_GRAPH_MST_KRUSKAL_HPP + diff --git a/deal.II/contrib/boost/include/boost/graph/leda_graph.hpp b/deal.II/contrib/boost/include/boost/graph/leda_graph.hpp new file mode 100644 index 0000000000..89c98ac26a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/leda_graph.hpp @@ -0,0 +1,549 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Copyright 2004 The Trustees of Indiana University. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek, Douglas Gregor +// +// 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_GRAPH_LEDA_HPP +#define BOOST_GRAPH_LEDA_HPP + +#include +#include +#include +#include + +#include +#include +#include + +// The functions and classes in this file allows the user to +// treat a LEDA GRAPH object as a boost graph "as is". No +// wrapper is needed for the GRAPH object. + +// Remember to define LEDA_PREFIX so that LEDA types such as +// leda_edge show up as "leda_edge" and not just "edge". + +// Warning: this implementation relies on partial specialization +// for the graph_traits class (so it won't compile with Visual C++) + +// Warning: this implementation is in alpha and has not been tested + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace boost { + + struct leda_graph_traversal_category : + public virtual bidirectional_graph_tag, + public virtual adjacency_graph_tag, + public virtual vertex_list_graph_tag { }; + + template + struct graph_traits< leda::GRAPH > { + typedef leda_node vertex_descriptor; + typedef leda_edge edge_descriptor; + + class adjacency_iterator + : public iterator_facade + { + public: + explicit adjacency_iterator(leda_edge edge = 0) : base(edge) {} + + private: + leda_node dereference() const { return leda::target(base); } + + bool equal(const adjacency_iterator& other) const + { return base == other.base; } + + void increment() { base = Succ_Adj_Edge(base, 0); } + void decrement() { base = Pred_Adj_Edge(base, 0); } + + leda_edge base; + + friend class iterator_core_access; + }; + + class out_edge_iterator + : public iterator_facade + { + public: + explicit out_edge_iterator(leda_edge edge = 0) : base(edge) {} + + private: + const leda_edge& dereference() const { return base; } + + bool equal(const out_edge_iterator& other) const + { return base == other.base; } + + void increment() { base = Succ_Adj_Edge(base, 0); } + void decrement() { base = Pred_Adj_Edge(base, 0); } + + leda_edge base; + + friend class iterator_core_access; + }; + + class in_edge_iterator + : public iterator_facade + { + public: + explicit in_edge_iterator(leda_edge edge = 0) : base(edge) {} + + private: + const leda_edge& dereference() const { return base; } + + bool equal(const in_edge_iterator& other) const + { return base == other.base; } + + void increment() { base = Succ_Adj_Edge(base, 1); } + void decrement() { base = Pred_Adj_Edge(base, 1); } + + leda_edge base; + + friend class iterator_core_access; + }; + + class vertex_iterator + : public iterator_facade + { + public: + vertex_iterator(leda_node node = 0, + const leda::GRAPH* g = 0) + : base(node), g(g) {} + + private: + const leda_node& dereference() const { return base; } + + bool equal(const vertex_iterator& other) const + { return base == other.base; } + + void increment() { base = g->succ_node(base); } + void decrement() { base = g->pred_node(base); } + + leda_node base; + const leda::GRAPH* g; + + friend class iterator_core_access; + }; + + typedef directed_tag directed_category; + typedef allow_parallel_edge_tag edge_parallel_category; // not sure here + typedef leda_graph_traversal_category traversal_category; + typedef int vertices_size_type; + typedef int edges_size_type; + typedef int degree_size_type; + }; + + template + struct vertex_property< leda::GRAPH > { + typedef vtype type; + }; + + template + struct edge_property< leda::GRAPH > { + typedef etype type; + }; + +} // namespace boost +#endif + +namespace boost { + + template + typename graph_traits< leda::GRAPH >::vertex_descriptor + source(typename graph_traits< leda::GRAPH >::edge_descriptor e, + const leda::GRAPH& g) + { + return source(e); + } + + template + typename graph_traits< leda::GRAPH >::vertex_descriptor + target(typename graph_traits< leda::GRAPH >::edge_descriptor e, + const leda::GRAPH& g) + { + return target(e); + } + + template + inline std::pair< + typename graph_traits< leda::GRAPH >::vertex_iterator, + typename graph_traits< leda::GRAPH >::vertex_iterator > + vertices(const leda::GRAPH& g) + { + typedef typename graph_traits< leda::GRAPH >::vertex_iterator + Iter; + return std::make_pair( Iter(g.first_node(),&g), Iter(0,&g) ); + } + + // no edges(g) function + + template + inline std::pair< + typename graph_traits< leda::GRAPH >::out_edge_iterator, + typename graph_traits< leda::GRAPH >::out_edge_iterator > + out_edges( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + const leda::GRAPH& g) + { + typedef typename graph_traits< leda::GRAPH > + ::out_edge_iterator Iter; + return std::make_pair( Iter(First_Adj_Edge(u,0)), Iter(0) ); + } + + template + inline std::pair< + typename graph_traits< leda::GRAPH >::in_edge_iterator, + typename graph_traits< leda::GRAPH >::in_edge_iterator > + in_edges( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + const leda::GRAPH& g) + { + typedef typename graph_traits< leda::GRAPH > + ::in_edge_iterator Iter; + return std::make_pair( Iter(First_Adj_Edge(u,1)), Iter(0) ); + } + + template + inline std::pair< + typename graph_traits< leda::GRAPH >::adjacency_iterator, + typename graph_traits< leda::GRAPH >::adjacency_iterator > + adjacent_vertices( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + const leda::GRAPH& g) + { + typedef typename graph_traits< leda::GRAPH > + ::adjacency_iterator Iter; + return std::make_pair( Iter(First_Adj_Edge(u,0)), Iter(0) ); + } + + template + typename graph_traits< leda::GRAPH >::vertices_size_type + num_vertices(const leda::GRAPH& g) + { + return g.number_of_nodes(); + } + + template + typename graph_traits< leda::GRAPH >::edges_size_type + num_edges(const leda::GRAPH& g) + { + return g.number_of_edges(); + } + + template + typename graph_traits< leda::GRAPH >::degree_size_type + out_degree( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + const leda::GRAPH&) + { + return outdeg(u); + } + + template + typename graph_traits< leda::GRAPH >::degree_size_type + in_degree( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + const leda::GRAPH&) + { + return indeg(u); + } + + template + typename graph_traits< leda::GRAPH >::degree_size_type + degree( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + const leda::GRAPH&) + { + return outdeg(u) + indeg(u); + } + + template + typename graph_traits< leda::GRAPH >::vertex_descriptor + add_vertex(leda::GRAPH& g) + { + return g.new_node(); + } + + template + typename graph_traits< leda::GRAPH >::vertex_descriptor + add_vertex(const vtype& vp, leda::GRAPH& g) + { + return g.new_node(vp); + } + + // Hmm, LEDA doesn't have the equivalent of clear_vertex() -JGS + // need to write an implementation + template + void clear_vertex( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + leda::GRAPH& g) + { + g.del_node(u); + } + + template + void remove_vertex( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + leda::GRAPH& g) + { + g.del_node(u); + } + + template + std::pair< + typename graph_traits< leda::GRAPH >::edge_descriptor, + bool> + add_edge( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + typename graph_traits< leda::GRAPH >::vertex_descriptor v, + leda::GRAPH& g) + { + return std::make_pair(g.new_edge(u, v), true); + } + + template + std::pair< + typename graph_traits< leda::GRAPH >::edge_descriptor, + bool> + add_edge( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + typename graph_traits< leda::GRAPH >::vertex_descriptor v, + const etype& et, + leda::GRAPH& g) + { + return std::make_pair(g.new_edge(u, v, et), true); + } + + template + void + remove_edge( + typename graph_traits< leda::GRAPH >::vertex_descriptor u, + typename graph_traits< leda::GRAPH >::vertex_descriptor v, + leda::GRAPH& g) + { + typename graph_traits< leda::GRAPH >::out_edge_iterator + i,iend; + for (boost::tie(i,iend) = out_edges(u,g); i != iend; ++i) + if (target(*i,g) == v) + g.del_edge(*i); + } + + template + void + remove_edge( + typename graph_traits< leda::GRAPH >::edge_descriptor e, + leda::GRAPH& g) + { + g.del_edge(e); + } + + //=========================================================================== + // property maps + + class leda_graph_id_map + : public put_get_helper + { + public: + typedef readable_property_map_tag category; + typedef int value_type; + typedef int reference; + typedef leda_node key_type; + leda_graph_id_map() { } + template + long operator[](T x) const { return x->id(); } + }; + template + inline leda_graph_id_map + get(vertex_index_t, const leda::GRAPH& g) { + return leda_graph_id_map(); + } + template + inline leda_graph_id_map + get(edge_index_t, const leda::GRAPH& g) { + return leda_graph_id_map(); + } + + template + struct leda_property_map { }; + + template <> + struct leda_property_map { + template + struct bind_ { + typedef leda_graph_id_map type; + typedef leda_graph_id_map const_type; + }; + }; + template <> + struct leda_property_map { + template + struct bind_ { + typedef leda_graph_id_map type; + typedef leda_graph_id_map const_type; + }; + }; + + + template + class leda_graph_data_map + : public put_get_helper > + { + public: + typedef Data value_type; + typedef DataRef reference; + typedef void key_type; + typedef lvalue_property_map_tag category; + leda_graph_data_map(GraphPtr g) : m_g(g) { } + template + DataRef operator[](NodeOrEdge x) const { return (*m_g)[x]; } + protected: + GraphPtr m_g; + }; + + template <> + struct leda_property_map { + template + struct bind_ { + typedef leda_graph_data_map*> type; + typedef leda_graph_data_map*> const_type; + }; + }; + template + inline typename property_map< leda::GRAPH, vertex_all_t>::type + get(vertex_all_t, leda::GRAPH& g) { + typedef typename property_map< leda::GRAPH, vertex_all_t>::type + pmap_type; + return pmap_type(&g); + } + template + inline typename property_map< leda::GRAPH, vertex_all_t>::const_type + get(vertex_all_t, const leda::GRAPH& g) { + typedef typename property_map< leda::GRAPH, + vertex_all_t>::const_type pmap_type; + return pmap_type(&g); + } + + template <> + struct leda_property_map { + template + struct bind_ { + typedef leda_graph_data_map*> type; + typedef leda_graph_data_map*> const_type; + }; + }; + template + inline typename property_map< leda::GRAPH, edge_all_t>::type + get(edge_all_t, leda::GRAPH& g) { + typedef typename property_map< leda::GRAPH, edge_all_t>::type + pmap_type; + return pmap_type(&g); + } + template + inline typename property_map< leda::GRAPH, edge_all_t>::const_type + get(edge_all_t, const leda::GRAPH& g) { + typedef typename property_map< leda::GRAPH, + edge_all_t>::const_type pmap_type; + return pmap_type(&g); + } + + // property map interface to the LEDA node_array class + + template + class leda_node_property_map + : public put_get_helper > + { + public: + typedef E value_type; + typedef ERef reference; + typedef leda_node key_type; + typedef lvalue_property_map_tag category; + leda_node_property_map(NodeMapPtr a) : m_array(a) { } + ERef operator[](leda_node n) const { return (*m_array)[n]; } + protected: + NodeMapPtr m_array; + }; + template + leda_node_property_map*> + make_leda_node_property_map(const leda_node_array& a) + { + typedef leda_node_property_map*> + pmap_type; + return pmap_type(&a); + } + template + leda_node_property_map*> + make_leda_node_property_map(leda_node_array& a) + { + typedef leda_node_property_map*> pmap_type; + return pmap_type(&a); + } + + template + leda_node_property_map*> + make_leda_node_property_map(const leda_node_map& a) + { + typedef leda_node_property_map*> + pmap_type; + return pmap_type(&a); + } + template + leda_node_property_map*> + make_leda_node_property_map(leda_node_map& a) + { + typedef leda_node_property_map*> pmap_type; + return pmap_type(&a); + } + + // g++ 'enumeral_type' in template unification not implemented workaround + template + struct property_map, Tag> { + typedef typename + leda_property_map::template bind_ map_gen; + typedef typename map_gen::type type; + typedef typename map_gen::const_type const_type; + }; + + template + inline + typename boost::property_traits< + typename boost::property_map,PropertyTag>::const_type + >::value_type + get(PropertyTag p, const leda::GRAPH& g, const Key& key) { + return get(get(p, g), key); + } + + template + inline void + put(PropertyTag p, leda::GRAPH& g, + const Key& key, const Value& value) + { + typedef typename property_map, PropertyTag>::type Map; + Map pmap = get(p, g); + put(pmap, key, value); + } + +} // namespace boost + + +#endif // BOOST_GRAPH_LEDA_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/matrix_as_graph.hpp b/deal.II/contrib/boost/include/boost/graph/matrix_as_graph.hpp new file mode 100644 index 0000000000..b39d126a23 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/matrix_as_graph.hpp @@ -0,0 +1,127 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_MATRIX2GRAPH_HPP +#define BOOST_GRAPH_MATRIX2GRAPH_HPP + +#include +#include +#include +#include +#include + +namespace boost { + + template + class matrix_adj_iterator; + + template + class matrix_incidence_iterator; + +} + +#define BOOST_GRAPH_ADAPT_MATRIX_TO_GRAPH(Matrix) \ +namespace boost { \ + template <> \ + struct graph_traits< Matrix > { \ + typedef Matrix::OneD::const_iterator Iter; \ + typedef Matrix::size_type V; \ + typedef V vertex_descriptor; \ + typedef Iter E; \ + typedef E edge_descriptor; \ + typedef boost::matrix_incidence_iterator out_edge_iterator; \ + typedef boost::matrix_adj_iterator adjacency_iterator; \ + typedef Matrix::size_type size_type; \ + typedef boost::int_iterator vertex_iterator; \ + \ + friend std::pair \ + vertices(const Matrix& g) { \ + typedef vertex_iterator VIter; \ + return std::make_pair(VIter(0), VIter(g.nrows())); \ + } \ + \ + friend std::pair \ + out_edges(V v, const Matrix& g) { \ + typedef out_edge_iterator IncIter; \ + return std::make_pair(IncIter(g[v].begin()), \ + IncIter(g[v].end())); \ + } \ + friend std::pair \ + adjacent_vertices(V v, const Matrix& g) { \ + typedef adjacency_iterator AdjIter; \ + return std::make_pair(AdjIter(g[v].begin()), \ + AdjIter(g[v].end())); \ + } \ + friend vertex_descriptor \ + source(E e, const Matrix& g) { \ + return e.row(); \ + } \ + friend vertex_descriptor \ + target(E e, const Matrix& g) { \ + return e.column(); \ + } \ + friend size_type \ + num_vertices(const Matrix& g) { \ + return g.nrows(); \ + } \ + friend size_type \ + num_edges(const Matrix& g) { \ + return g.nnz(); \ + } \ + friend size_type \ + out_degree(V i, const Matrix& g) { \ + return g[i].nnz(); \ + } \ + }; \ +} + +namespace boost { + + template + class matrix_adj_iterator + : public std::iterator + { + typedef matrix_adj_iterator self; + public: + matrix_adj_iterator() { } + matrix_adj_iterator(Iter i) : _iter(i) { } + matrix_adj_iterator(const self& x) : _iter(x._iter) { } + self& operator=(const self& x) { _iter = x._iter; return *this; } + Vertex operator*() { return _iter.column(); } + self& operator++() { ++_iter; return *this; } + self operator++(int) { self t = *this; ++_iter; return t; } + bool operator==(const self& x) const { return _iter == x._iter; } + bool operator!=(const self& x) const { return _iter != x._iter; } + protected: + Iter _iter; + }; + + template + class matrix_incidence_iterator + : public std::iterator + { + typedef matrix_incidence_iterator self; + public: + matrix_incidence_iterator() { } + matrix_incidence_iterator(Iter i) : _iter(i) { } + matrix_incidence_iterator(const self& x) : _iter(x._iter) { } + self& operator=(const self& x) { _iter = x._iter; return *this; } + Iter operator*() { return _iter; } + self& operator++() { ++_iter; return *this; } + self operator++(int) { self t = *this; ++_iter; return t; } + bool operator==(const self& x) const { return _iter == x._iter; } + bool operator!=(const self& x) const { return _iter != x._iter; } + protected: + Iter _iter; + }; + +} /* namespace boost */ + +#endif /* BOOST_GRAPH_MATRIX2GRAPH_HPP*/ diff --git a/deal.II/contrib/boost/include/boost/graph/minimum_degree_ordering.hpp b/deal.II/contrib/boost/include/boost/graph/minimum_degree_ordering.hpp new file mode 100644 index 0000000000..6aa242dcc5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/minimum_degree_ordering.hpp @@ -0,0 +1,655 @@ +//-*-c++-*- +//======================================================================= +// Copyright 1997-2001 University of Notre Dame. +// Authors: Lie-Quan Lee, Jeremy Siek +// +// 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 MINIMUM_DEGREE_ORDERING_HPP +#define MINIMUM_DEGREE_ORDERING_HPP + +#include +#include +#include +#include +#include // for integer_traits +#include +#include + +namespace boost { + + namespace detail { + + // + // Given a set of n integers (where the integer values range from + // zero to n-1), we want to keep track of a collection of stacks + // of integers. It so happens that an integer will appear in at + // most one stack at a time, so the stacks form disjoint sets. + // Because of these restrictions, we can use one big array to + // store all the stacks, intertwined with one another. + // No allocation/deallocation happens in the push()/pop() methods + // so this is faster than using std::stack's. + // + template + class Stacks { + typedef SignedInteger value_type; + typedef typename std::vector::size_type size_type; + public: + Stacks(size_type n) : data(n) {} + + //: stack + class stack { + typedef typename std::vector::iterator Iterator; + public: + stack(Iterator _data, const value_type& head) + : data(_data), current(head) {} + + // did not use default argument here to avoid internal compiler error + // in g++. + stack(Iterator _data) + : data(_data), current(-(std::numeric_limits::max)()) {} + + void pop() { + assert(! empty()); + current = data[current]; + } + void push(value_type v) { + data[v] = current; + current = v; + } + bool empty() { + return current == -(std::numeric_limits::max)(); + } + value_type& top() { return current; } + private: + Iterator data; + value_type current; + }; + + // To return a stack object + stack make_stack() + { return stack(data.begin()); } + protected: + std::vector data; + }; + + + // marker class, a generalization of coloring. + // + // This class is to provide a generalization of coloring which has + // complexity of amortized constant time to set all vertices' color + // back to be untagged. It implemented by increasing a tag. + // + // The colors are: + // not tagged + // tagged + // multiple_tagged + // done + // + template + class Marker { + typedef SignedInteger value_type; + typedef typename std::vector::size_type size_type; + + static value_type done() + { return (std::numeric_limits::max)()/2; } + public: + Marker(size_type _num, VertexIndexMap index_map) + : tag(1 - (std::numeric_limits::max)()), + data(_num, - (std::numeric_limits::max)()), + id(index_map) {} + + void mark_done(Vertex node) { data[get(id, node)] = done(); } + + bool is_done(Vertex node) { return data[get(id, node)] == done(); } + + void mark_tagged(Vertex node) { data[get(id, node)] = tag; } + + void mark_multiple_tagged(Vertex node) { data[get(id, node)] = multiple_tag; } + + bool is_tagged(Vertex node) const { return data[get(id, node)] >= tag; } + + bool is_not_tagged(Vertex node) const { return data[get(id, node)] < tag; } + + bool is_multiple_tagged(Vertex node) const + { return data[get(id, node)] >= multiple_tag; } + + void increment_tag() { + const size_type num = data.size(); + ++tag; + if ( tag >= done() ) { + tag = 1 - (std::numeric_limits::max)(); + for (size_type i = 0; i < num; ++i) + if ( data[i] < done() ) + data[i] = - (std::numeric_limits::max)(); + } + } + + void set_multiple_tag(value_type mdeg0) + { + const size_type num = data.size(); + multiple_tag = tag + mdeg0; + + if ( multiple_tag >= done() ) { + tag = 1-(std::numeric_limits::max)(); + + for (size_type i=0; i::max)(); + + multiple_tag = tag + mdeg0; + } + } + + void set_tag_as_multiple_tag() { tag = multiple_tag; } + + protected: + value_type tag; + value_type multiple_tag; + std::vector data; + VertexIndexMap id; + }; + + template< class Iterator, class SignedInteger, + class Vertex, class VertexIndexMap, int offset = 1 > + class Numbering { + typedef SignedInteger number_type; + number_type num; //start from 1 instead of zero + Iterator data; + number_type max_num; + VertexIndexMap id; + public: + Numbering(Iterator _data, number_type _max_num, VertexIndexMap id) + : num(1), data(_data), max_num(_max_num), id(id) {} + void operator()(Vertex node) { data[get(id, node)] = -num; } + bool all_done(number_type i = 0) const { return num + i > max_num; } + void increment(number_type i = 1) { num += i; } + bool is_numbered(Vertex node) const { + return data[get(id, node)] < 0; + } + void indistinguishable(Vertex i, Vertex j) { + data[get(id, i)] = - (get(id, j) + offset); + } + }; + + template + class degreelists_marker { + public: + typedef SignedInteger value_type; + typedef typename std::vector::size_type size_type; + degreelists_marker(size_type n, VertexIndexMap id) + : marks(n, 0), id(id) {} + void mark_need_update(Vertex i) { marks[get(id, i)] = 1; } + bool need_update(Vertex i) { return marks[get(id, i)] == 1; } + bool outmatched_or_done (Vertex i) { return marks[get(id, i)] == -1; } + void mark(Vertex i) { marks[get(id, i)] = -1; } + void unmark(Vertex i) { marks[get(id, i)] = 0; } + private: + std::vector marks; + VertexIndexMap id; + }; + + // Helper function object for edge removal + template + class predicateRemoveEdge1 { + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename graph_traits::edge_descriptor edge_t; + public: + predicateRemoveEdge1(Graph& _g, MarkerP& _marker, + NumberD _numbering, Stack& n_e, VertexIndexMap id) + : g(&_g), marker(&_marker), numbering(_numbering), + neighbor_elements(&n_e), id(id) {} + + bool operator()(edge_t e) { + vertex_t dist = target(e, *g); + if ( marker->is_tagged(dist) ) + return true; + marker->mark_tagged(dist); + if (numbering.is_numbered(dist)) { + neighbor_elements->push(get(id, dist)); + return true; + } + return false; + } + private: + Graph* g; + MarkerP* marker; + NumberD numbering; + Stack* neighbor_elements; + VertexIndexMap id; + }; + + // Helper function object for edge removal + template + class predicate_remove_tagged_edges + { + typedef typename graph_traits::vertex_descriptor vertex_t; + typedef typename graph_traits::edge_descriptor edge_t; + public: + predicate_remove_tagged_edges(Graph& _g, MarkerP& _marker) + : g(&_g), marker(&_marker) {} + + bool operator()(edge_t e) { + vertex_t dist = target(e, *g); + if ( marker->is_tagged(dist) ) + return true; + return false; + } + private: + Graph* g; + MarkerP* marker; + }; + + template + class mmd_impl + { + // Typedefs + typedef graph_traits Traits; + typedef typename Traits::vertices_size_type size_type; + typedef typename detail::integer_traits::difference_type + diff_t; + typedef typename Traits::vertex_descriptor vertex_t; + typedef typename Traits::adjacency_iterator adj_iter; + typedef iterator_property_map IndexVertexMap; + typedef detail::Stacks Workspace; + typedef bucket_sorter + DegreeLists; + typedef Numbering + NumberingD; + typedef degreelists_marker + DegreeListsMarker; + typedef Marker MarkerP; + + // Data Members + + // input parameters + Graph& G; + int delta; + DegreeMap degree; + InversePermutationMap inverse_perm; + PermutationMap perm; + SuperNodeMap supernode_size; + VertexIndexMap vertex_index_map; + + // internal data-structures + std::vector index_vertex_vec; + size_type n; + IndexVertexMap index_vertex_map; + DegreeLists degreelists; + NumberingD numbering; + DegreeListsMarker degree_lists_marker; + MarkerP marker; + Workspace work_space; + public: + mmd_impl(Graph& g, size_type n_, int delta, DegreeMap degree, + InversePermutationMap inverse_perm, + PermutationMap perm, + SuperNodeMap supernode_size, + VertexIndexMap id) + : G(g), delta(delta), degree(degree), + inverse_perm(inverse_perm), + perm(perm), + supernode_size(supernode_size), + vertex_index_map(id), + index_vertex_vec(n_), + n(n_), + degreelists(n_ + 1, n_, degree, id), + numbering(inverse_perm, n_, vertex_index_map), + degree_lists_marker(n_, vertex_index_map), + marker(n_, vertex_index_map), + work_space(n_) + { + typename graph_traits::vertex_iterator v, vend; + size_type vid = 0; + for (tie(v, vend) = vertices(G); v != vend; ++v, ++vid) + index_vertex_vec[vid] = *v; + index_vertex_map = IndexVertexMap(&index_vertex_vec[0]); + + // Initialize degreelists. Degreelists organizes the nodes + // according to their degree. + for (tie(v, vend) = vertices(G); v != vend; ++v) { + put(degree, *v, out_degree(*v, G)); + degreelists.push(*v); + } + } + + void do_mmd() + { + // Eliminate the isolated nodes -- these are simply the nodes + // with no neighbors, which are accessible as a list (really, a + // stack) at location 0. Since these don't affect any other + // nodes, we can eliminate them without doing degree updates. + typename DegreeLists::stack list_isolated = degreelists[0]; + while (!list_isolated.empty()) { + vertex_t node = list_isolated.top(); + marker.mark_done(node); + numbering(node); + numbering.increment(); + list_isolated.pop(); + } + size_type min_degree = 1; + typename DegreeLists::stack list_min_degree = degreelists[min_degree]; + + while (list_min_degree.empty()) { + ++min_degree; + list_min_degree = degreelists[min_degree]; + } + + // check if the whole eliminating process is done + while (!numbering.all_done()) { + + size_type min_degree_limit = min_degree + delta; // WARNING + typename Workspace::stack llist = work_space.make_stack(); + + // multiple elimination + while (delta >= 0) { + + // Find the next non-empty degree + for (list_min_degree = degreelists[min_degree]; + list_min_degree.empty() && min_degree <= min_degree_limit; + ++min_degree, list_min_degree = degreelists[min_degree]) + ; + if (min_degree > min_degree_limit) + break; + + const vertex_t node = list_min_degree.top(); + const size_type node_id = get(vertex_index_map, node); + list_min_degree.pop(); + numbering(node); + + // check if node is the last one + if (numbering.all_done(supernode_size[node])) { + numbering.increment(supernode_size[node]); + break; + } + marker.increment_tag(); + marker.mark_tagged(node); + + this->eliminate(node); + + numbering.increment(supernode_size[node]); + llist.push(node_id); + } // multiple elimination + + if (numbering.all_done()) + break; + + this->update( llist, min_degree); + } + + } // do_mmd() + + void eliminate(vertex_t node) + { + typename Workspace::stack element_neighbor = work_space.make_stack(); + + // Create two function objects for edge removal + typedef typename Workspace::stack WorkStack; + predicateRemoveEdge1 + p(G, marker, numbering, element_neighbor, vertex_index_map); + + predicate_remove_tagged_edges p2(G, marker); + + // Reconstruct the adjacent node list, push element neighbor in a List. + remove_out_edge_if(node, p, G); + //during removal element neighbors are collected. + + while (!element_neighbor.empty()) { + // element absorb + size_type e_id = element_neighbor.top(); + vertex_t element = get(index_vertex_map, e_id); + adj_iter i, i_end; + for (tie(i, i_end) = adjacent_vertices(element, G); i != i_end; ++i){ + vertex_t i_node = *i; + if (!marker.is_tagged(i_node) && !numbering.is_numbered(i_node)) { + marker.mark_tagged(i_node); + add_edge(node, i_node, G); + } + } + element_neighbor.pop(); + } + adj_iter v, ve; + for (tie(v, ve) = adjacent_vertices(node, G); v != ve; ++v) { + vertex_t v_node = *v; + if (!degree_lists_marker.need_update(v_node) + && !degree_lists_marker.outmatched_or_done(v_node)) { + degreelists.remove(v_node); + } + //update out edges of v_node + remove_out_edge_if(v_node, p2, G); + + if ( out_degree(v_node, G) == 0 ) { // indistinguishable nodes + supernode_size[node] += supernode_size[v_node]; + supernode_size[v_node] = 0; + numbering.indistinguishable(v_node, node); + marker.mark_done(v_node); + degree_lists_marker.mark(v_node); + } else { // not indistinguishable nodes + add_edge(v_node, node, G); + degree_lists_marker.mark_need_update(v_node); + } + } + } // eliminate() + + + template + void update(Stack llist, size_type& min_degree) + { + size_type min_degree0 = min_degree + delta + 1; + + while (! llist.empty()) { + size_type deg, deg0 = 0; + + marker.set_multiple_tag(min_degree0); + typename Workspace::stack q2list = work_space.make_stack(); + typename Workspace::stack qxlist = work_space.make_stack(); + + vertex_t current = get(index_vertex_map, llist.top()); + adj_iter i, ie; + for (tie(i,ie) = adjacent_vertices(current, G); i != ie; ++i) { + vertex_t i_node = *i; + const size_type i_id = get(vertex_index_map, i_node); + if (supernode_size[i_node] != 0) { + deg0 += supernode_size[i_node]; + marker.mark_multiple_tagged(i_node); + if (degree_lists_marker.need_update(i_node)) { + if (out_degree(i_node, G) == 2) + q2list.push(i_id); + else + qxlist.push(i_id); + } + } + } + + while (!q2list.empty()) { + const size_type u_id = q2list.top(); + vertex_t u_node = get(index_vertex_map, u_id); + // if u_id is outmatched by others, no need to update degree + if (degree_lists_marker.outmatched_or_done(u_node)) { + q2list.pop(); + continue; + } + marker.increment_tag(); + deg = deg0; + + adj_iter nu = adjacent_vertices(u_node, G).first; + vertex_t neighbor = *nu; + if (neighbor == u_node) { + ++nu; + neighbor = *nu; + } + if (numbering.is_numbered(neighbor)) { + adj_iter i, ie; + for (tie(i,ie) = adjacent_vertices(neighbor, G); + i != ie; ++i) { + const vertex_t i_node = *i; + if (i_node == u_node || supernode_size[i_node] == 0) + continue; + if (marker.is_tagged(i_node)) { + if (degree_lists_marker.need_update(i_node)) { + if ( out_degree(i_node, G) == 2 ) { // is indistinguishable + supernode_size[u_node] += supernode_size[i_node]; + supernode_size[i_node] = 0; + numbering.indistinguishable(i_node, u_node); + marker.mark_done(i_node); + degree_lists_marker.mark(i_node); + } else // is outmatched + degree_lists_marker.mark(i_node); + } + } else { + marker.mark_tagged(i_node); + deg += supernode_size[i_node]; + } + } + } else + deg += supernode_size[neighbor]; + + deg -= supernode_size[u_node]; + degree[u_node] = deg; //update degree + degreelists[deg].push(u_node); + //u_id has been pushed back into degreelists + degree_lists_marker.unmark(u_node); + if (min_degree > deg) + min_degree = deg; + q2list.pop(); + } // while (!q2list.empty()) + + while (!qxlist.empty()) { + const size_type u_id = qxlist.top(); + const vertex_t u_node = get(index_vertex_map, u_id); + + // if u_id is outmatched by others, no need to update degree + if (degree_lists_marker.outmatched_or_done(u_node)) { + qxlist.pop(); + continue; + } + marker.increment_tag(); + deg = deg0; + adj_iter i, ie; + for (tie(i, ie) = adjacent_vertices(u_node, G); i != ie; ++i) { + vertex_t i_node = *i; + if (marker.is_tagged(i_node)) + continue; + marker.mark_tagged(i_node); + + if (numbering.is_numbered(i_node)) { + adj_iter j, je; + for (tie(j, je) = adjacent_vertices(i_node, G); j != je; ++j) { + const vertex_t j_node = *j; + if (marker.is_not_tagged(j_node)) { + marker.mark_tagged(j_node); + deg += supernode_size[j_node]; + } + } + } else + deg += supernode_size[i_node]; + } // for adjacent vertices of u_node + deg -= supernode_size[u_node]; + degree[u_node] = deg; + degreelists[deg].push(u_node); + // u_id has been pushed back into degreelists + degree_lists_marker.unmark(u_node); + if (min_degree > deg) + min_degree = deg; + qxlist.pop(); + } // while (!qxlist.empty()) { + + marker.set_tag_as_multiple_tag(); + llist.pop(); + } // while (! llist.empty()) + + } // update() + + + void build_permutation(InversePermutationMap next, + PermutationMap prev) + { + // collect the permutation info + size_type i; + for (i = 0; i < n; ++i) { + diff_t size = supernode_size[get(index_vertex_map, i)]; + if ( size <= 0 ) { + prev[i] = next[i]; + supernode_size[get(index_vertex_map, i)] + = next[i] + 1; // record the supernode info + } else + prev[i] = - next[i]; + } + for (i = 1; i < n + 1; ++i) { + if ( prev[i-1] > 0 ) + continue; + diff_t parent = i; + while ( prev[parent - 1] < 0 ) { + parent = - prev[parent - 1]; + } + + diff_t root = parent; + diff_t num = prev[root - 1] + 1; + next[i-1] = - num; + prev[root-1] = num; + + parent = i; + diff_t next_node = - prev[parent - 1]; + while (next_node > 0) { + prev[parent-1] = - root; + parent = next_node; + next_node = - prev[parent - 1]; + } + } + for (i = 0; i < n; i++) { + diff_t num = - next[i] - 1; + next[i] = num; + prev[num] = i; + } + } // build_permutation() + }; + + } //namespace detail + + + // MMD algorithm + // + //The implementation presently includes the enhancements for mass + //elimination, incomplete degree update, multiple elimination, and + //external degree. + // + //Important Note: This implementation requires the BGL graph to be + //directed. Therefore, nonzero entry (i, j) in a symmetrical matrix + //A coresponds to two directed edges (i->j and j->i). + // + //see Alan George and Joseph W. H. Liu, The Evolution of the Minimum + //Degree Ordering Algorithm, SIAM Review, 31, 1989, Page 1-19 + template + void minimum_degree_ordering + (Graph& G, + DegreeMap degree, + InversePermutationMap inverse_perm, + PermutationMap perm, + SuperNodeMap supernode_size, + int delta, + VertexIndexMap vertex_index_map) + { + detail::mmd_impl + impl(G, num_vertices(G), delta, degree, inverse_perm, + perm, supernode_size, vertex_index_map); + impl.do_mmd(); + impl.build_permutation(inverse_perm, perm); + } + +} // namespace boost + +#endif // MINIMUM_DEGREE_ORDERING_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/named_function_params.hpp b/deal.II/contrib/boost/include/boost/graph/named_function_params.hpp new file mode 100644 index 0000000000..2cb37c31f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/named_function_params.hpp @@ -0,0 +1,738 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_NAMED_FUNCTION_PARAMS_HPP +#define BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP + +#include + +namespace boost { + + struct distance_compare_t { }; + struct distance_combine_t { }; + struct distance_inf_t { }; + struct distance_zero_t { }; + struct buffer_param_t { }; + struct edge_copy_t { }; + struct vertex_copy_t { }; + struct vertex_isomorphism_t { }; + struct vertex_invariant_t { }; + struct vertex_invariant1_t { }; + struct vertex_invariant2_t { }; + struct edge_compare_t { }; + struct vertex_max_invariant_t { }; + struct orig_to_copy_t { }; + struct root_vertex_t { }; + struct attractive_force_t { }; + struct repulsive_force_t { }; + struct force_pairs_t { }; + struct cooling_t { }; + struct vertex_displacement_t { }; + struct iterations_t { }; + struct diameter_range_t { }; + struct learning_constant_range_t { }; + + namespace detail { + template + struct wrap_ref { + wrap_ref(T& r) : ref(r) {} + T& ref; + }; + } + + template + struct bgl_named_params : public Base + { + typedef bgl_named_params self; + typedef Base next_type; + typedef Tag tag_type; + typedef T value_type; + bgl_named_params(T v) : m_value(v) { } + bgl_named_params(T v, const Base& b) : Base(b), m_value(v) { } + T m_value; + + template + bgl_named_params + weight_map(const WeightMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + weight_map2(const WeightMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + distance_map(const DistanceMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + predecessor_map(const PredecessorMap& pmap) const { + typedef bgl_named_params + Params; + return Params(pmap, *this); + } + + template + bgl_named_params + rank_map(const RankMap& pmap) const { + typedef bgl_named_params + Params; + return Params(pmap, *this); + } + + template + bgl_named_params + root_map(const RootMap& pmap) const { + typedef bgl_named_params + Params; + return Params(pmap, *this); + } + + template + bgl_named_params + root_vertex(const Vertex& r) const { + typedef bgl_named_params Params; + return Params(r, *this); + } + + template + bgl_named_params + edge_centrality_map(const EdgeCentralityMap& r) const { + typedef bgl_named_params Params; + return Params(r, *this); + } + + template + bgl_named_params + centrality_map(const CentralityMap& r) const { + typedef bgl_named_params Params; + return Params(r, *this); + } + + template + bgl_named_params + color_map(const ColorMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + vertex_color_map(const ColorMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + edge_color_map(const ColorMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + capacity_map(CapacityMap pmap) { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + residual_capacity_map(Residual_CapacityMap pmap) { + typedef bgl_named_params + Params; + return Params(pmap, *this); + } + + template + bgl_named_params + reverse_edge_map(ReverseMap pmap) { + typedef bgl_named_params + Params; + return Params(pmap, *this); + } + + template + bgl_named_params + discover_time_map(const DiscoverTimeMap& pmap) const { + typedef bgl_named_params + Params; + return Params(pmap, *this); + } + + template + bgl_named_params + vertex_index_map(const IndexMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + vertex_index1_map(const IndexMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + vertex_index2_map(const IndexMap& pmap) const { + typedef bgl_named_params Params; + return Params(pmap, *this); + } + + template + bgl_named_params + visitor(const Visitor& vis) const { + typedef bgl_named_params Params; + return Params(vis, *this); + } + + template + bgl_named_params + distance_compare(Compare cmp) const { + typedef bgl_named_params Params; + return Params(cmp, *this); + } + + template + bgl_named_params + distance_combine(Combine cmb) const { + typedef bgl_named_params Params; + return Params(cmb, *this); + } + + template + bgl_named_params + distance_inf(Init init) const { + typedef bgl_named_params Params; + return Params(init, *this); + } + + template + bgl_named_params + distance_zero(Init init) const { + typedef bgl_named_params Params; + return Params(init, *this); + } + + template + bgl_named_params, buffer_param_t, self> + buffer(Buffer& b) const { + typedef bgl_named_params, buffer_param_t, self> + Params; + return Params(detail::wrap_ref(b), *this); + } + + template + bgl_named_params + edge_copy(const Copier& c) const { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + vertex_copy(const Copier& c) const { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + orig_to_copy(const Orig2CopyMap& c) const { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + isomorphism_map(const IsoMap& c) const { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + vertex_invariant(const VertexInvar& c) const { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + displacement_map(const VertexDisplacement& c) const { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + attractive_force(const AttractiveForce& c) { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + repulsive_force(const RepulsiveForce& c) { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + force_pairs(const ForcePairs& c) { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + cooling(const Cooling& c) { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params + iterations(const TP& c) { + typedef bgl_named_params Params; + return Params(c, *this); + } + + template + bgl_named_params, diameter_range_t, self> + diameter_range(const std::pair& c) { + typedef bgl_named_params, diameter_range_t, self> Params; + return Params(c, *this); + } + + template + bgl_named_params, learning_constant_range_t, self> + learning_constant_range(const std::pair& c) { + typedef bgl_named_params, learning_constant_range_t, self> + Params; + return Params(c, *this); + } + }; + + template + bgl_named_params + weight_map(WeightMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + weight_map2(WeightMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + distance_map(DistanceMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + predecessor_map(PredecessorMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + rank_map(RankMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + root_map(RootMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + root_vertex(const Vertex& r) { + typedef bgl_named_params Params; + return Params(r); + } + + template + bgl_named_params + edge_centrality_map(const EdgeCentralityMap& r) { + typedef bgl_named_params Params; + return Params(r); + } + + template + bgl_named_params + centrality_map(const CentralityMap& r) { + typedef bgl_named_params Params; + return Params(r); + } + + template + bgl_named_params + color_map(ColorMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + capacity_map(CapacityMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + residual_capacity_map(Residual_CapacityMap pmap) { + typedef bgl_named_params + Params; + return Params(pmap); + } + + template + bgl_named_params + reverse_edge_map(ReverseMap pmap) { + typedef bgl_named_params + Params; + return Params(pmap); + } + + template + bgl_named_params + discover_time_map(DiscoverTimeMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + vertex_index_map(IndexMap pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + vertex_index1_map(const IndexMap& pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + vertex_index2_map(const IndexMap& pmap) { + typedef bgl_named_params Params; + return Params(pmap); + } + + template + bgl_named_params + visitor(const Visitor& vis) { + typedef bgl_named_params Params; + return Params(vis); + } + + template + bgl_named_params + distance_compare(Compare cmp) { + typedef bgl_named_params Params; + return Params(cmp); + } + + template + bgl_named_params + distance_combine(Combine cmb) { + typedef bgl_named_params Params; + return Params(cmb); + } + + template + bgl_named_params + distance_inf(Init init) { + typedef bgl_named_params Params; + return Params(init); + } + + template + bgl_named_params + distance_zero(Init init) { + typedef bgl_named_params Params; + return Params(init); + } + + template + bgl_named_params, buffer_param_t> + buffer(Buffer& b) { + typedef bgl_named_params, buffer_param_t> Params; + return Params(detail::wrap_ref(b)); + } + + template + bgl_named_params + edge_copy(const Copier& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + vertex_copy(const Copier& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + orig_to_copy(const Orig2CopyMap& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + isomorphism_map(const IsoMap& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + vertex_invariant(const VertexInvar& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + displacement_map(const VertexDisplacement& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + attractive_force(const AttractiveForce& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + repulsive_force(const RepulsiveForce& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + force_pairs(const ForcePairs& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + cooling(const Cooling& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params + iterations(const T& c) { + typedef bgl_named_params Params; + return Params(c); + } + + template + bgl_named_params, diameter_range_t> + diameter_range(const std::pair& c) { + typedef bgl_named_params, diameter_range_t> Params; + return Params(c); + } + + template + bgl_named_params, learning_constant_range_t> + learning_constant_range(const std::pair& c) { + typedef bgl_named_params, learning_constant_range_t> + Params; + return Params(c); + } + + //=========================================================================== + // Functions for extracting parameters from bgl_named_params + + template + inline + typename property_value< bgl_named_params, Tag2>::type + get_param(const bgl_named_params& p, Tag2 tag2) + { + enum { match = detail::same_property::value }; + typedef typename + property_value< bgl_named_params, Tag2>::type T2; + T2* t2 = 0; + typedef detail::property_value_dispatch Dispatcher; + return Dispatcher::const_get_value(p, t2, tag2); + } + + + namespace detail { + // MSVC++ workaround + template + struct choose_param_helper { + template struct result { typedef Param type; }; + template + static const Param& apply(const Param& p, const Default&) { return p; } + }; + template <> + struct choose_param_helper { + template struct result { typedef Default type; }; + template + static const Default& apply(const error_property_not_found&, const Default& d) + { return d; } + }; + } // namespace detail + + template + const typename detail::choose_param_helper

::template result::type& + choose_param(const P& param, const Default& d) { + return detail::choose_param_helper

::apply(param, d); + } + + template + inline bool is_default_param(const T&) { return false; } + + inline bool is_default_param(const detail::error_property_not_found&) + { return true; } + + namespace detail { + + struct choose_parameter { + template + struct bind_ { + typedef const P& const_result_type; + typedef const P& result_type; + typedef P type; + }; + + template + static typename bind_::const_result_type + const_apply(const P& p, const Graph&, Tag&) + { return p; } + + template + static typename bind_::result_type + apply(const P& p, Graph&, Tag&) + { return p; } + }; + + struct choose_default_param { + template + struct bind_ { + typedef typename property_map::type + result_type; + typedef typename property_map::const_type + const_result_type; + typedef typename property_map::const_type + type; + }; + + template + static typename bind_::const_result_type + const_apply(const P&, const Graph& g, Tag tag) { + return get(tag, g); + } + template + static typename bind_::result_type + apply(const P&, Graph& g, Tag tag) { + return get(tag, g); + } + }; + + template + struct choose_property_map { + typedef choose_parameter type; + }; + template <> + struct choose_property_map { + typedef choose_default_param type; + }; + + template + struct choose_pmap_helper { + typedef typename choose_property_map::type Selector; + typedef typename Selector:: template bind_ Bind; + typedef Bind type; + typedef typename Bind::result_type result_type; + typedef typename Bind::const_result_type const_result_type; + typedef typename Bind::type result; + }; + + // used in the max-flow algorithms + template + struct edge_capacity_value + { + typedef bgl_named_params Params; + typedef typename property_value< Params, edge_capacity_t>::type Param; + typedef typename detail::choose_pmap_helper::result CapacityEdgeMap; + typedef typename property_traits::value_type type; + }; + + } // namespace detail + + + // Use this function instead of choose_param() when you want + // to avoid requiring get(tag, g) when it is not used. + template + typename + detail::choose_pmap_helper::const_result_type + choose_const_pmap(const Param& p, const Graph& g, PropertyTag tag) + { + typedef typename + detail::choose_pmap_helper::Selector Choice; + return Choice::const_apply(p, g, tag); + } + + template + typename detail::choose_pmap_helper::result_type + choose_pmap(const Param& p, Graph& g, PropertyTag tag) + { + typedef typename + detail::choose_pmap_helper::Selector Choice; + return Choice::apply(p, g, tag); + } + +} // namespace boost + +#endif // BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/neighbor_bfs.hpp b/deal.II/contrib/boost/include/boost/graph/neighbor_bfs.hpp new file mode 100644 index 0000000000..1c7b9782ac --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/neighbor_bfs.hpp @@ -0,0 +1,323 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_NEIGHBOR_BREADTH_FIRST_SEARCH_HPP +#define BOOST_GRAPH_NEIGHBOR_BREADTH_FIRST_SEARCH_HPP + +/* + Neighbor Breadth First Search + Like BFS, but traverses in-edges as well as out-edges. + (for directed graphs only. use normal BFS for undirected graphs) +*/ +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + struct NeighborBFSVisitorConcept { + void constraints() { + function_requires< CopyConstructibleConcept >(); + vis.initialize_vertex(u, g); + vis.discover_vertex(u, g); + vis.examine_vertex(u, g); + vis.examine_out_edge(e, g); + vis.examine_in_edge(e, g); + vis.tree_out_edge(e, g); + vis.tree_in_edge(e, g); + vis.non_tree_out_edge(e, g); + vis.non_tree_in_edge(e, g); + vis.gray_target(e, g); + vis.black_target(e, g); + vis.gray_source(e, g); + vis.black_source(e, g); + vis.finish_vertex(u, g); + } + Visitor vis; + Graph g; + typename graph_traits::vertex_descriptor u; + typename graph_traits::edge_descriptor e; + }; + + template + class neighbor_bfs_visitor { + public: + neighbor_bfs_visitor(Visitors vis = Visitors()) : m_vis(vis) { } + + template + void initialize_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, on_initialize_vertex()); + } + template + void discover_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, on_discover_vertex()); + } + template + void examine_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, on_examine_vertex()); + } + template + void examine_out_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_examine_edge()); + } + template + void tree_out_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_tree_edge()); + } + template + void non_tree_out_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_non_tree_edge()); + } + template + void gray_target(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_gray_target()); + } + template + void black_target(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_black_target()); + } + template + void examine_in_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_examine_edge()); + } + template + void tree_in_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_tree_edge()); + } + template + void non_tree_in_edge(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_non_tree_edge()); + } + template + void gray_source(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_gray_target()); + } + template + void black_source(Edge e, Graph& g) { + invoke_visitors(m_vis, e, g, on_black_target()); + } + template + void finish_vertex(Vertex u, Graph& g) { + invoke_visitors(m_vis, u, g, on_finish_vertex()); + } + protected: + Visitors m_vis; + }; + + template + neighbor_bfs_visitor + make_neighbor_bfs_visitor(Visitors vis) { + return neighbor_bfs_visitor(vis); + } + + namespace detail { + + template + void neighbor_bfs_impl + (const BidirectionalGraph& g, + typename graph_traits::vertex_descriptor s, + Buffer& Q, BFSVisitor vis, ColorMap color) + + { + function_requires< BidirectionalGraphConcept >(); + typedef graph_traits GTraits; + typedef typename GTraits::vertex_descriptor Vertex; + typedef typename GTraits::edge_descriptor Edge; + function_requires< + NeighborBFSVisitorConcept >(); + function_requires< ReadWritePropertyMapConcept >(); + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + put(color, s, Color::gray()); + vis.discover_vertex(s, g); + Q.push(s); + while (! Q.empty()) { + Vertex u = Q.top(); + Q.pop(); // pop before push to avoid problem if Q is priority_queue. + vis.examine_vertex(u, g); + + typename GTraits::out_edge_iterator ei, ei_end; + for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { + Edge e = *ei; + vis.examine_out_edge(e, g); + Vertex v = target(e, g); + ColorValue v_color = get(color, v); + if (v_color == Color::white()) { + vis.tree_out_edge(e, g); + put(color, v, Color::gray()); + vis.discover_vertex(v, g); + Q.push(v); + } else { + vis.non_tree_out_edge(e, g); + if (v_color == Color::gray()) + vis.gray_target(e, g); + else + vis.black_target(e, g); + } + } // for out-edges + + typename GTraits::in_edge_iterator in_ei, in_ei_end; + for (tie(in_ei, in_ei_end) = in_edges(u, g); + in_ei != in_ei_end; ++in_ei) { + Edge e = *in_ei; + vis.examine_in_edge(e, g); + Vertex v = source(e, g); + ColorValue v_color = get(color, v); + if (v_color == Color::white()) { + vis.tree_in_edge(e, g); + put(color, v, Color::gray()); + vis.discover_vertex(v, g); + Q.push(v); + } else { + vis.non_tree_in_edge(e, g); + if (v_color == Color::gray()) + vis.gray_source(e, g); + else + vis.black_source(e, g); + } + } // for in-edges + + put(color, u, Color::black()); + vis.finish_vertex(u, g); + } // while + } + + + template + void neighbor_bfs_helper + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + ColorMap color, + BFSVisitor vis, + const bgl_named_params& params) + { + typedef graph_traits Traits; + // Buffer default + typedef typename Traits::vertex_descriptor Vertex; + typedef boost::queue queue_t; + queue_t Q; + detail::wrap_ref Qref(Q); + // Initialization + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename boost::graph_traits::vertex_iterator i, i_end; + for (tie(i, i_end) = vertices(g); i != i_end; ++i) { + put(color, *i, Color::white()); + vis.initialize_vertex(*i, g); + } + neighbor_bfs_impl + (g, s, + choose_param(get_param(params, buffer_param_t()), Qref).ref, + vis, color); + } + + //------------------------------------------------------------------------- + // Choose between default color and color parameters. Using + // function dispatching so that we don't require vertex index if + // the color default is not being used. + + template + struct neighbor_bfs_dispatch { + template + static void apply + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params, + ColorMap color) + { + neighbor_bfs_helper + (g, s, color, + choose_param(get_param(params, graph_visitor), + make_neighbor_bfs_visitor(null_visitor())), + params); + } + }; + + template <> + struct neighbor_bfs_dispatch { + template + static void apply + (VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params, + detail::error_property_not_found) + { + std::vector color_vec(num_vertices(g)); + null_visitor null_vis; + + neighbor_bfs_helper + (g, s, + make_iterator_property_map + (color_vec.begin(), + choose_const_pmap(get_param(params, vertex_index), + g, vertex_index), color_vec[0]), + choose_param(get_param(params, graph_visitor), + make_neighbor_bfs_visitor(null_vis)), + params); + } + }; + + } // namespace detail + + + // Named Parameter Variant + template + void neighbor_breadth_first_search + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params) + { + // The graph is passed by *const* reference so that graph adaptors + // (temporaries) can be passed into this function. However, the + // graph is not really const since we may write to property maps + // of the graph. + VertexListGraph& ng = const_cast(g); + typedef typename property_value< bgl_named_params, + vertex_color_t>::type C; + detail::neighbor_bfs_dispatch::apply(ng, s, params, + get_param(params, vertex_color)); + } + + + // This version does not initialize colors, user has to. + + template + void neighbor_breadth_first_visit + (IncidenceGraph& g, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params) + { + typedef graph_traits Traits; + // Buffer default + typedef boost::queue queue_t; + queue_t Q; + detail::wrap_ref Qref(Q); + + detail::neighbor_bfs_impl + (g, s, + choose_param(get_param(params, buffer_param_t()), Qref).ref, + choose_param(get_param(params, graph_visitor), + make_neighbor_bfs_visitor(null_visitor())), + choose_pmap(get_param(params, vertex_color), g, vertex_color) + ); + } + +} // namespace boost + +#endif // BOOST_GRAPH_NEIGHBOR_BREADTH_FIRST_SEARCH_HPP + diff --git a/deal.II/contrib/boost/include/boost/graph/page_rank.hpp b/deal.II/contrib/boost/include/boost/graph/page_rank.hpp new file mode 100644 index 0000000000..78ae766d28 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/page_rank.hpp @@ -0,0 +1,153 @@ +// Copyright 2004-5 The Trustees of Indiana University. +// Copyright 2002 Brad King and Douglas Gregor + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine + +#ifndef BOOST_GRAPH_PAGE_RANK_HPP +#define BOOST_GRAPH_PAGE_RANK_HPP + +#include +#include +#include +#include +#include + +namespace boost { namespace graph { + +struct n_iterations +{ + explicit n_iterations(std::size_t n) : n(n) { } + + template + bool + operator()(const RankMap&, const Graph&) + { + return n-- == 0; + } + + private: + std::size_t n; +}; + +namespace detail { + template + void page_rank_step(const Graph& g, RankMap from_rank, RankMap2 to_rank, + typename property_traits::value_type damping, + incidence_graph_tag) + { + typedef typename property_traits::value_type rank_type; + + // Set new rank maps + BGL_FORALL_VERTICES_T(v, g, Graph) put(to_rank, v, rank_type(1 - damping)); + + BGL_FORALL_VERTICES_T(u, g, Graph) { + rank_type u_rank_out = damping * get(from_rank, u) / out_degree(u, g); + BGL_FORALL_ADJ_T(u, v, g, Graph) + put(to_rank, v, get(to_rank, v) + u_rank_out); + } + } + + template + void page_rank_step(const Graph& g, RankMap from_rank, RankMap2 to_rank, + typename property_traits::value_type damping, + bidirectional_graph_tag) + { + typedef typename property_traits::value_type damping_type; + BGL_FORALL_VERTICES_T(v, g, Graph) { + typename property_traits::value_type rank(0); + BGL_FORALL_INEDGES_T(v, e, g, Graph) + rank += get(from_rank, source(e, g)) / out_degree(source(e, g), g); + put(to_rank, v, (damping_type(1) - damping) + damping * rank); + } + } +} // end namespace detail + +template +void +page_rank(const Graph& g, RankMap rank_map, Done done, + typename property_traits::value_type damping, + typename graph_traits::vertices_size_type n, + RankMap2 rank_map2) +{ + typedef typename property_traits::value_type rank_type; + + rank_type initial_rank = rank_type(rank_type(1) / n); + BGL_FORALL_VERTICES_T(v, g, Graph) put(rank_map, v, initial_rank); + + bool to_map_2 = true; + while ((to_map_2 && !done(rank_map, g)) || + (!to_map_2 && !done(rank_map2, g))) { + typedef typename graph_traits::traversal_category category; + + if (to_map_2) { + detail::page_rank_step(g, rank_map, rank_map2, damping, category()); + } else { + detail::page_rank_step(g, rank_map2, rank_map, damping, category()); + } + to_map_2 = !to_map_2; + } + + if (!to_map_2) { + BGL_FORALL_VERTICES_T(v, g, Graph) put(rank_map, v, get(rank_map2, v)); + } +} + +template +void +page_rank(const Graph& g, RankMap rank_map, Done done, + typename property_traits::value_type damping, + typename graph_traits::vertices_size_type n) +{ + typedef typename property_traits::value_type rank_type; + + std::vector ranks2(num_vertices(g)); + page_rank(g, rank_map, done, damping, n, + make_iterator_property_map(ranks2.begin(), get(vertex_index, g))); +} + +template +inline void +page_rank(const Graph& g, RankMap rank_map, Done done, + typename property_traits::value_type damping = 0.85) +{ + page_rank(g, rank_map, done, damping, num_vertices(g)); +} + +template +inline void +page_rank(const Graph& g, RankMap rank_map) +{ + page_rank(g, rank_map, n_iterations(20)); +} + +// TBD: this could be _much_ more efficient, using a queue to store +// the vertices that should be reprocessed and keeping track of which +// vertices are in the queue with a property map. Baah, this only +// applies when we have a bidirectional graph. +template +void +remove_dangling_links(MutableGraph& g) +{ + typename graph_traits::vertices_size_type old_n; + do { + old_n = num_vertices(g); + + typename graph_traits::vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g); vi != vi_end; /* in loop */) { + typename graph_traits::vertex_descriptor v = *vi++; + if (out_degree(v, g) == 0) { + clear_vertex(v, g); + remove_vertex(v, g); + } + } + } while (num_vertices(g) < old_n); +} + +} } // end namespace boost::graph + +#endif // BOOST_GRAPH_PAGE_RANK_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/plod_generator.hpp b/deal.II/contrib/boost/include/boost/graph/plod_generator.hpp new file mode 100644 index 0000000000..324594a01d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/plod_generator.hpp @@ -0,0 +1,157 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_PLOD_GENERATOR_HPP +#define BOOST_GRAPH_PLOD_GENERATOR_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + template + class plod_iterator + { + typedef std::vector > out_degrees_t; + typedef typename graph_traits::directed_category directed_category; + + public: + typedef std::input_iterator_tag iterator_category; + typedef std::pair value_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef void difference_type; + + plod_iterator() + : gen(0), out_degrees(), degrees_left(0), allow_self_loops(false) { } + + plod_iterator(RandomGenerator& gen, std::size_t n, + double alpha, double beta, bool allow_self_loops = false) + : gen(&gen), n(n), out_degrees(new out_degrees_t(n)), + degrees_left(0), allow_self_loops(allow_self_loops) + { + using std::pow; + + uniform_int x(0, n-1); + for (out_degrees_t::iterator i = out_degrees->begin(); + i != out_degrees->end(); ++i) { + std::size_t xv = x(gen); + i->first = i - out_degrees->begin(); + i->second = (xv == 0? 0 : std::size_t(beta * pow(xv, -alpha))); + degrees_left += i->second; + } + + next(directed_category()); + } + + reference operator*() const { return current; } + pointer operator->() const { return ¤t; } + + plod_iterator& operator++() + { + next(directed_category()); + return *this; + } + + plod_iterator operator++(int) + { + plod_iterator temp(*this); + ++(*this); + return temp; + } + + bool operator==(const plod_iterator& other) const + { + return degrees_left == other.degrees_left; + } + + bool operator!=(const plod_iterator& other) const + { return !(*this == other); } + + private: + void next(directed_tag) + { + uniform_int x(0, out_degrees->size()-1); + std::size_t source; + do { + source = x(*gen); + } while ((*out_degrees)[source].second == 0); + current.first = (*out_degrees)[source].first; + current.second = x(*gen); + --degrees_left; + if (--(*out_degrees)[source].second == 0) { + (*out_degrees)[source] = out_degrees->back(); + out_degrees->pop_back(); + } + } + + void next(undirected_tag) + { + std::size_t source, target; + while (true) { + /* We may get to the point where we can't actually find any + new edges, so we just add some random edge and set the + degrees left = 0 to signal termination. */ + if (out_degrees->size() < 2) { + uniform_int x(0, n); + current.first = x(*gen); + do { + current.second = x(*gen); + } while (current.first == current.second && !allow_self_loops); + degrees_left = 0; + out_degrees->clear(); + return; + } + + uniform_int x(0, out_degrees->size()-1); + + // Select source vertex + source = x(*gen); + if ((*out_degrees)[source].second == 0) { + (*out_degrees)[source] = out_degrees->back(); + out_degrees->pop_back(); + continue; + } + + // Select target vertex + target = x(*gen); + if ((*out_degrees)[target].second == 0) { + (*out_degrees)[target] = out_degrees->back(); + out_degrees->pop_back(); + continue; + } else if (source != target + || (allow_self_loops && (*out_degrees)[source].second > 2)) { + break; + } + } + + // Update degree counts + --(*out_degrees)[source].second; + --degrees_left; + --(*out_degrees)[target].second; + --degrees_left; + current.first = (*out_degrees)[source].first; + current.second = (*out_degrees)[target].first; + } + + RandomGenerator* gen; + std::size_t n; + shared_ptr out_degrees; + std::size_t degrees_left; + bool allow_self_loops; + value_type current; + }; + +} // end namespace boost + +#endif // BOOST_GRAPH_PLOD_GENERATOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/prim_minimum_spanning_tree.hpp b/deal.II/contrib/boost/include/boost/graph/prim_minimum_spanning_tree.hpp new file mode 100644 index 0000000000..79913b1a5c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/prim_minimum_spanning_tree.hpp @@ -0,0 +1,91 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_MST_PRIM_HPP +#define BOOST_GRAPH_MST_PRIM_HPP + +#include +#include +#include + +namespace boost { + + namespace detail { + // this should be somewhere else in boost... + template struct _project2nd { + V operator()(U, V v) const { return v; } + }; + } + + namespace detail { + + // This is Prim's algorithm to calculate the Minimum Spanning Tree + // for an undirected graph with weighted edges. + + template + inline void + prim_mst_impl(const Graph& G, + typename graph_traits::vertex_descriptor s, + const bgl_named_params& params, + Weight) + { + typedef typename property_traits::value_type W; + std::less compare; + detail::_project2nd combine; + dijkstra_shortest_paths(G, s, params.distance_compare(compare). + distance_combine(combine)); + } + } // namespace detail + + template + inline void + prim_minimum_spanning_tree + (const VertexListGraph& g, + typename graph_traits::vertex_descriptor s, + PredecessorMap predecessor, DistanceMap distance, WeightMap weight, + IndexMap index_map, + DijkstraVisitor vis) + { + typedef typename property_traits::value_type W; + std::less compare; + detail::_project2nd combine; + dijkstra_shortest_paths(g, s, predecessor, distance, weight, index_map, + compare, combine, (std::numeric_limits::max)(), 0, + vis); + } + + template + inline void prim_minimum_spanning_tree + (const VertexListGraph& g, + PredecessorMap p_map, + const bgl_named_params& params) + { + detail::prim_mst_impl + (g, + choose_param(get_param(params, root_vertex_t()), *vertices(g).first), + params.predecessor_map(p_map), + choose_const_pmap(get_param(params, edge_weight), g, edge_weight)); + } + + template + inline void prim_minimum_spanning_tree + (const VertexListGraph& g, PredecessorMap p_map) + { + detail::prim_mst_impl + (g, *vertices(g).first, predecessor_map(p_map). + weight_map(get(edge_weight, g)), + get(edge_weight, g)); + } + +} // namespace boost + +#endif // BOOST_GRAPH_MST_PRIM_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/profile.hpp b/deal.II/contrib/boost/include/boost/graph/profile.hpp new file mode 100755 index 0000000000..2ae7b8e7fe --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/profile.hpp @@ -0,0 +1,60 @@ +// +//======================================================================= +// Copyright 2002 Marc Wintermantel (wintermantel@imes.mavt.ethz.ch) +// ETH Zurich, Center of Structure Technologies (www.imes.ethz.ch/st) +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// + +#ifndef BOOST_GRAPH_PROFILE_HPP +#define BOOST_GRAPH_PROFILE_HPP + +#include +#include +#include + +namespace boost { + + template + typename graph_traits::vertices_size_type + profile(const Graph& g, VertexIndexMap index) + { + typename graph_traits::vertices_size_type b = 0; + typename graph_traits::vertex_iterator i, end; + for (tie(i, end) = vertices(g); i != end; ++i){ + b += ith_bandwidth(*i, g, index) + 1; + } + + return b; + } + + template + typename graph_traits::vertices_size_type + profile(const Graph& g) + { + return profile(g, get(vertex_index, g)); + } + + +} // namespace boost + +#endif // BOOST_GRAPH_PROFILE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/properties.hpp b/deal.II/contrib/boost/include/boost/graph/properties.hpp new file mode 100644 index 0000000000..2b30348a9a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/properties.hpp @@ -0,0 +1,368 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_PROPERTIES_HPP +#define BOOST_GRAPH_PROPERTIES_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + + enum default_color_type { white_color, gray_color, green_color, red_color, black_color }; + + template + struct color_traits { + static default_color_type white() { return white_color; } + static default_color_type gray() { return gray_color; } + static default_color_type green() { return green_color; } + static default_color_type red() { return red_color; } + static default_color_type black() { return black_color; } + }; + + // These functions are now obsolete, replaced by color_traits. + inline default_color_type white(default_color_type) { return white_color; } + inline default_color_type gray(default_color_type) { return gray_color; } + inline default_color_type green(default_color_type) { return green_color; } + inline default_color_type red(default_color_type) { return red_color; } + inline default_color_type black(default_color_type) { return black_color; } + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template <> + struct property_traits { + typedef default_color_type value_type; + typedef std::ptrdiff_t key_type; + typedef default_color_type& reference; + typedef lvalue_property_map_tag category; + }; + // get/put already defined for T* +#endif + + struct graph_property_tag { }; + struct vertex_property_tag { }; + struct edge_property_tag { }; + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + // See examples/edge_property.cpp for how to use this. +#define BOOST_INSTALL_PROPERTY(KIND, NAME) \ + template <> struct property_kind { \ + typedef KIND##_property_tag type; \ + } +#else +#define BOOST_INSTALL_PROPERTY(KIND, NAME) \ + template <> struct property_kind { \ + typedef KIND##_property_tag type; \ + } +#endif + +#define BOOST_DEF_PROPERTY(KIND, NAME) \ + enum KIND##_##NAME##_t { KIND##_##NAME }; \ + BOOST_INSTALL_PROPERTY(KIND, NAME) + + BOOST_DEF_PROPERTY(vertex, all); + BOOST_DEF_PROPERTY(edge, all); + BOOST_DEF_PROPERTY(graph, all); + BOOST_DEF_PROPERTY(vertex, index); + BOOST_DEF_PROPERTY(vertex, index1); + BOOST_DEF_PROPERTY(vertex, index2); + BOOST_DEF_PROPERTY(vertex, root); + BOOST_DEF_PROPERTY(edge, index); + BOOST_DEF_PROPERTY(edge, name); + BOOST_DEF_PROPERTY(edge, weight); + BOOST_DEF_PROPERTY(edge, weight2); + BOOST_DEF_PROPERTY(edge, color); + BOOST_DEF_PROPERTY(vertex, name); + BOOST_DEF_PROPERTY(graph, name); + BOOST_DEF_PROPERTY(vertex, distance); + BOOST_DEF_PROPERTY(vertex, color); + BOOST_DEF_PROPERTY(vertex, degree); + BOOST_DEF_PROPERTY(vertex, in_degree); + BOOST_DEF_PROPERTY(vertex, out_degree); + BOOST_DEF_PROPERTY(vertex, current_degree); + BOOST_DEF_PROPERTY(vertex, priority); + BOOST_DEF_PROPERTY(vertex, discover_time); + BOOST_DEF_PROPERTY(vertex, finish_time); + BOOST_DEF_PROPERTY(vertex, predecessor); + BOOST_DEF_PROPERTY(vertex, rank); + BOOST_DEF_PROPERTY(vertex, centrality); + BOOST_DEF_PROPERTY(edge, reverse); + BOOST_DEF_PROPERTY(edge, capacity); + BOOST_DEF_PROPERTY(edge, residual_capacity); + BOOST_DEF_PROPERTY(edge, centrality); + BOOST_DEF_PROPERTY(graph, visitor); + + // These tags are used for property bundles + BOOST_DEF_PROPERTY(vertex, bundle); + BOOST_DEF_PROPERTY(edge, bundle); + +#undef BOOST_DEF_PROPERTY + + namespace detail { + + struct dummy_edge_property_selector { + template + struct bind_ { + typedef identity_property_map type; + typedef identity_property_map const_type; + }; + }; + struct dummy_vertex_property_selector { + template + struct bind_ { + typedef identity_property_map type; + typedef identity_property_map const_type; + }; + }; + + } // namespace detail + + // Graph classes can either partially specialize property_map + // or they can specialize these two selector classes. + template + struct edge_property_selector { + typedef detail::dummy_edge_property_selector type; + }; + + template + struct vertex_property_selector { + typedef detail::dummy_vertex_property_selector type; + }; + + namespace detail { + + template + struct edge_property_map { + typedef typename Graph::edge_property_type Property; + typedef typename Graph::graph_tag graph_tag; + typedef typename edge_property_selector::type Selector; + typedef typename Selector::template bind_ + Bind; + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + template + class vertex_property_map { + typedef typename Graph::vertex_property_type Property; + typedef typename Graph::graph_tag graph_tag; + typedef typename vertex_property_selector::type Selector; + typedef typename Selector::template bind_ + Bind; + public: + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + + // This selects the kind of property map, whether is maps from + // edges or from vertices. + // + // It is overly complicated because it's a workaround for + // partial specialization. + struct choose_vertex_property_map { + template + struct bind_ { + typedef vertex_property_map type; + }; + }; + struct choose_edge_property_map { + template + struct bind_ { + typedef edge_property_map type; + }; + }; + template + struct property_map_kind_selector { + // VC++ gets confused if this isn't defined, even though + // this never gets used. + typedef choose_vertex_property_map type; + }; + template <> struct property_map_kind_selector { + typedef choose_vertex_property_map type; + }; + template <> struct property_map_kind_selector { + typedef choose_edge_property_map type; + }; + } // namespace detail + + template + struct property_map { + private: + typedef typename property_kind::type Kind; + typedef typename detail::property_map_kind_selector::type Selector; + typedef typename Selector::template bind_ Bind; + typedef typename Bind::type Map; + public: + typedef typename Map::type type; + typedef typename Map::const_type const_type; + }; + + // shortcut for accessing the value type of the property map + template + class property_map_value { + typedef typename property_map::const_type PMap; + public: + typedef typename property_traits::value_type type; + }; + + template + class graph_property { + public: + typedef typename property_value::type type; + }; + + template + class vertex_property { + public: + typedef typename Graph::vertex_property_type type; + }; + template + class edge_property { + public: + typedef typename Graph::edge_property_type type; + }; + + template + class degree_property_map + : public put_get_helper::degree_size_type, + degree_property_map > + { + public: + typedef typename graph_traits::vertex_descriptor key_type; + typedef typename graph_traits::degree_size_type value_type; + typedef value_type reference; + typedef readable_property_map_tag category; + degree_property_map(const Graph& g) : m_g(g) { } + value_type operator[](const key_type& v) const { + return degree(v, m_g); + } + private: + const Graph& m_g; + }; + template + inline degree_property_map + make_degree_map(const Graph& g) { + return degree_property_map(g); + } + + //======================================================================== + // Iterator Property Map Generating Functions contributed by + // Kevin Vanhorn. (see also the property map generating functions + // in boost/property_map.hpp) + +#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) + // A helper function for creating a vertex property map out of a + // random access iterator and the internal vertex index map from a + // graph. + template + inline + iterator_property_map< + RandomAccessIterator, + typename property_map::type, + typename std::iterator_traits::value_type, + typename std::iterator_traits::reference + > + make_iterator_vertex_map(RandomAccessIterator iter, const PropertyGraph& g) + { + return make_iterator_property_map(iter, get(vertex_index, g)); + } + + // Use this next function when vertex_descriptor is known to be an + // integer type, with values ranging from 0 to num_vertices(g). + // + template + inline + iterator_property_map< + RandomAccessIterator, + identity_property_map, + typename std::iterator_traits::value_type, + typename std::iterator_traits::reference + > + make_iterator_vertex_map(RandomAccessIterator iter) + { + return make_iterator_property_map(iter, identity_property_map()); + } +#endif + + template + inline + iterator_property_map< + typename RandomAccessContainer::iterator, + typename property_map::type, + typename RandomAccessContainer::value_type, + typename RandomAccessContainer::reference + > + make_container_vertex_map(RandomAccessContainer& c, const PropertyGraph& g) + { + assert(c.size() >= num_vertices(g)); + return make_iterator_vertex_map(c.begin(), g); + } + + template inline + iterator_property_map< + typename RandomAccessContainer::iterator, + identity_property_map, + typename RandomAccessContainer::value_type, + typename RandomAccessContainer::reference + > + make_container_vertex_map(RandomAccessContainer& c) + { + return make_iterator_vertex_map(c.begin()); + } + +#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# define BOOST_GRAPH_NO_BUNDLED_PROPERTIES +#endif + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + template + struct bundle_property_map + : put_get_helper > + { + typedef Descriptor key_type; + typedef T value_type; + typedef T& reference; + typedef lvalue_property_map_tag category; + + bundle_property_map(Graph* g_, T Bundle::* pm_) : g(g_), pm(pm_) {} + + reference operator[](key_type k) const { return (*g)[k].*pm; } + private: + Graph* g; + T Bundle::* pm; + }; + + namespace detail { + template + struct is_vertex_bundle : is_convertible {}; + } + + template + struct property_map + { + private: + typedef graph_traits traits; + typedef typename Graph::vertex_bundled vertex_bundled; + typedef typename Graph::edge_bundled edge_bundled; + typedef typename ct_if<(detail::is_vertex_bundle::value), + typename traits::vertex_descriptor, + typename traits::edge_descriptor>::type + descriptor; + + public: + typedef bundle_property_map type; + typedef bundle_property_map const_type; + }; +#endif + +} // namespace boost + +#endif /* BOOST_GRAPH_PROPERTIES_HPPA */ diff --git a/deal.II/contrib/boost/include/boost/graph/property_iter_range.hpp b/deal.II/contrib/boost/include/boost/graph/property_iter_range.hpp new file mode 100644 index 0000000000..dfab03e30e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/property_iter_range.hpp @@ -0,0 +1,118 @@ + +// (C) Copyright François Faure, iMAGIS-GRAVIR / UJF, 2001. Permission +// to copy, use, modify, sell and distribute this software is granted +// provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with +// no claim as to its suitability for any purpose. + +// Revision History: +// 03 May 2001 Jeremy Siek +// Generalized the property map iterator and moved that +// part to boost/property_map.hpp. Also modified to +// differentiate between const/mutable graphs and +// added a workaround to avoid partial specialization. + +// 02 May 2001 François Faure +// Initial version. + +#ifndef BOOST_GRAPH_PROPERTY_ITER_RANGE_HPP +#define BOOST_GRAPH_PROPERTY_ITER_RANGE_HPP + +#include +#include +#include +#include + +namespace boost { + +//====================================================================== +// graph property iterator range + + template + class graph_property_iter_range { + typedef typename property_map::type map_type; + typedef typename property_map::const_type + const_map_type; + typedef typename property_kind::type Kind; + typedef typename ct_if::value, + typename graph_traits::vertex_iterator, + typename graph_traits::edge_iterator>::type iter; + public: + typedef typename property_map_iterator_generator::type + iterator; + typedef typename property_map_iterator_generator + ::type const_iterator; + typedef std::pair type; + typedef std::pair const_type; + }; + + namespace detail { + + template + typename graph_property_iter_range::type + get_property_iter_range_kind(Graph& graph, const Tag& tag, + const vertex_property_tag& ) + { + typedef typename graph_property_iter_range::iterator iter; + return std::make_pair(iter(vertices(graph).first, get(tag, graph)), + iter(vertices(graph).second, get(tag, graph))); + } + + template + typename graph_property_iter_range::const_type + get_property_iter_range_kind(const Graph& graph, const Tag& tag, + const vertex_property_tag& ) + { + typedef typename graph_property_iter_range + ::const_iterator iter; + return std::make_pair(iter(vertices(graph).first, get(tag, graph)), + iter(vertices(graph).second, get(tag, graph))); + } + + + template + typename graph_property_iter_range::type + get_property_iter_range_kind(Graph& graph, const Tag& tag, + const edge_property_tag& ) + { + typedef typename graph_property_iter_range::iterator iter; + return std::make_pair(iter(edges(graph).first, get(tag, graph)), + iter(edges(graph).second, get(tag, graph))); + } + + template + typename graph_property_iter_range::const_type + get_property_iter_range_kind(const Graph& graph, const Tag& tag, + const edge_property_tag& ) + { + typedef typename graph_property_iter_range + ::const_iterator iter; + return std::make_pair(iter(edges(graph).first, get(tag, graph)), + iter(edges(graph).second, get(tag, graph))); + } + + } // namespace detail + + //====================================================================== + // get an iterator range of properties + + template + typename graph_property_iter_range::type + get_property_iter_range(Graph& graph, const Tag& tag) + { + typedef typename property_kind::type Kind; + return detail::get_property_iter_range_kind(graph, tag, Kind()); + } + + template + typename graph_property_iter_range::const_type + get_property_iter_range(const Graph& graph, const Tag& tag) + { + typedef typename property_kind::type Kind; + return detail::get_property_iter_range_kind(graph, tag, Kind()); + } + +} // namespace boost + + +#endif // BOOST_GRAPH_PROPERTY_ITER_RANGE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/push_relabel_max_flow.hpp b/deal.II/contrib/boost/include/boost/graph/push_relabel_max_flow.hpp new file mode 100644 index 0000000000..987b8cfe4c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/push_relabel_max_flow.hpp @@ -0,0 +1,727 @@ +//======================================================================= +// Copyright 2000 University of Notre Dame. +// Authors: Jeremy G. Siek, Andrew Lumsdaine, Lie-Quan Lee +// +// 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_PUSH_RELABEL_MAX_FLOW_HPP +#define BOOST_PUSH_RELABEL_MAX_FLOW_HPP + +#include +#include +#include +#include +#include +#include // for std::min and std::max + +#include +#include +#include +#include + +namespace boost { + + namespace detail { + + // This implementation is based on Goldberg's + // "On Implementing Push-Relabel Method for the Maximum Flow Problem" + // by B.V. Cherkassky and A.V. Goldberg, IPCO '95, pp. 157--171 + // and on the h_prf.c and hi_pr.c code written by the above authors. + + // This implements the highest-label version of the push-relabel method + // with the global relabeling and gap relabeling heuristics. + + // The terms "rank", "distance", "height" are synonyms in + // Goldberg's implementation, paper and in the CLR. A "layer" is a + // group of vertices with the same distance. The vertices in each + // layer are categorized as active or inactive. An active vertex + // has positive excess flow and its distance is less than n (it is + // not blocked). + + template + struct preflow_layer { + std::list active_vertices; + std::list inactive_vertices; + }; + + template integer + class FlowValue> + class push_relabel + { + public: + typedef graph_traits Traits; + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + typedef typename Traits::vertex_iterator vertex_iterator; + typedef typename Traits::out_edge_iterator out_edge_iterator; + typedef typename Traits::vertices_size_type vertices_size_type; + typedef typename Traits::edges_size_type edges_size_type; + + typedef preflow_layer Layer; + typedef std::vector< Layer > LayerArray; + typedef typename LayerArray::iterator layer_iterator; + typedef typename LayerArray::size_type distance_size_type; + + typedef color_traits ColorTraits; + + //======================================================================= + // Some helper predicates + + inline bool is_admissible(vertex_descriptor u, vertex_descriptor v) { + return distance[u] == distance[v] + 1; + } + inline bool is_residual_edge(edge_descriptor a) { + return 0 < residual_capacity[a]; + } + inline bool is_saturated(edge_descriptor a) { + return residual_capacity[a] == 0; + } + + //======================================================================= + // Layer List Management Functions + + typedef typename std::list::iterator list_iterator; + + void add_to_active_list(vertex_descriptor u, Layer& layer) { + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + layer.active_vertices.push_front(u); + max_active = max BOOST_PREVENT_MACRO_SUBSTITUTION(distance[u], max_active); + min_active = min BOOST_PREVENT_MACRO_SUBSTITUTION(distance[u], min_active); + layer_list_ptr[u] = layer.active_vertices.begin(); + } + void remove_from_active_list(vertex_descriptor u) { + layers[distance[u]].active_vertices.erase(layer_list_ptr[u]); + } + + void add_to_inactive_list(vertex_descriptor u, Layer& layer) { + layer.inactive_vertices.push_front(u); + layer_list_ptr[u] = layer.inactive_vertices.begin(); + } + void remove_from_inactive_list(vertex_descriptor u) { + layers[distance[u]].inactive_vertices.erase(layer_list_ptr[u]); + } + + //======================================================================= + // initialization + push_relabel(Graph& g_, + EdgeCapacityMap cap, + ResidualCapacityEdgeMap res, + ReverseEdgeMap rev, + vertex_descriptor src_, + vertex_descriptor sink_, + VertexIndexMap idx) + : g(g_), n(num_vertices(g_)), capacity(cap), src(src_), sink(sink_), + index(idx), + excess_flow(num_vertices(g_)), + current(num_vertices(g_), out_edges(*vertices(g_).first, g_).second), + distance(num_vertices(g_)), + color(num_vertices(g_)), + reverse_edge(rev), + residual_capacity(res), + layers(num_vertices(g_)), + layer_list_ptr(num_vertices(g_), + layers.front().inactive_vertices.end()), + push_count(0), update_count(0), relabel_count(0), + gap_count(0), gap_node_count(0), + work_since_last_update(0) + { + vertex_iterator u_iter, u_end; + // Don't count the reverse edges + edges_size_type m = num_edges(g) / 2; + nm = alpha() * n + m; + + // Initialize flow to zero which means initializing + // the residual capacity to equal the capacity. + out_edge_iterator ei, e_end; + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) + for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei) { + residual_capacity[*ei] = capacity[*ei]; + } + + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) { + vertex_descriptor u = *u_iter; + excess_flow[u] = 0; + current[u] = out_edges(u, g).first; + } + + bool overflow_detected = false; + FlowValue test_excess = 0; + + out_edge_iterator a_iter, a_end; + for (tie(a_iter, a_end) = out_edges(src, g); a_iter != a_end; ++a_iter) + if (target(*a_iter, g) != src) + test_excess += residual_capacity[*a_iter]; + if (test_excess > (std::numeric_limits::max)()) + overflow_detected = true; + + if (overflow_detected) + excess_flow[src] = (std::numeric_limits::max)(); + else { + excess_flow[src] = 0; + for (tie(a_iter, a_end) = out_edges(src, g); + a_iter != a_end; ++a_iter) { + edge_descriptor a = *a_iter; + if (target(a, g) != src) { + ++push_count; + FlowValue delta = residual_capacity[a]; + residual_capacity[a] -= delta; + residual_capacity[reverse_edge[a]] += delta; + excess_flow[target(a, g)] += delta; + } + } + } + max_distance = num_vertices(g) - 1; + max_active = 0; + min_active = n; + + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) { + vertex_descriptor u = *u_iter; + if (u == sink) { + distance[u] = 0; + continue; + } else if (u == src && !overflow_detected) + distance[u] = n; + else + distance[u] = 1; + + if (excess_flow[u] > 0) + add_to_active_list(u, layers[1]); + else if (distance[u] < n) + add_to_inactive_list(u, layers[1]); + } + + } // push_relabel constructor + + //======================================================================= + // This is a breadth-first search over the residual graph + // (well, actually the reverse of the residual graph). + // Would be cool to have a graph view adaptor for hiding certain + // edges, like the saturated (non-residual) edges in this case. + // Goldberg's implementation abused "distance" for the coloring. + void global_distance_update() + { + BOOST_USING_STD_MAX(); + ++update_count; + vertex_iterator u_iter, u_end; + for (tie(u_iter,u_end) = vertices(g); u_iter != u_end; ++u_iter) { + color[*u_iter] = ColorTraits::white(); + distance[*u_iter] = n; + } + color[sink] = ColorTraits::gray(); + distance[sink] = 0; + + for (distance_size_type l = 0; l <= max_distance; ++l) { + layers[l].active_vertices.clear(); + layers[l].inactive_vertices.clear(); + } + + max_distance = max_active = 0; + min_active = n; + + Q.push(sink); + while (! Q.empty()) { + vertex_descriptor u = Q.top(); + Q.pop(); + distance_size_type d_v = distance[u] + 1; + + out_edge_iterator ai, a_end; + for (tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) { + edge_descriptor a = *ai; + vertex_descriptor v = target(a, g); + if (color[v] == ColorTraits::white() + && is_residual_edge(reverse_edge[a])) { + distance[v] = d_v; + color[v] = ColorTraits::gray(); + current[v] = out_edges(v, g).first; + max_distance = max BOOST_PREVENT_MACRO_SUBSTITUTION(d_v, max_distance); + + if (excess_flow[v] > 0) + add_to_active_list(v, layers[d_v]); + else + add_to_inactive_list(v, layers[d_v]); + + Q.push(v); + } + } + } + } // global_distance_update() + + //======================================================================= + // This function is called "push" in Goldberg's h_prf implementation, + // but it is called "discharge" in the paper and in hi_pr.c. + void discharge(vertex_descriptor u) + { + assert(excess_flow[u] > 0); + while (1) { + out_edge_iterator ai, ai_end; + for (ai = current[u], ai_end = out_edges(u, g).second; + ai != ai_end; ++ai) { + edge_descriptor a = *ai; + if (is_residual_edge(a)) { + vertex_descriptor v = target(a, g); + if (is_admissible(u, v)) { + ++push_count; + if (v != sink && excess_flow[v] == 0) { + remove_from_inactive_list(v); + add_to_active_list(v, layers[distance[v]]); + } + push_flow(a); + if (excess_flow[u] == 0) + break; + } + } + } // for out_edges of i starting from current + + Layer& layer = layers[distance[u]]; + distance_size_type du = distance[u]; + + if (ai == ai_end) { // i must be relabeled + relabel_distance(u); + if (layer.active_vertices.empty() + && layer.inactive_vertices.empty()) + gap(du); + if (distance[u] == n) + break; + } else { // i is no longer active + current[u] = ai; + add_to_inactive_list(u, layer); + break; + } + } // while (1) + } // discharge() + + //======================================================================= + // This corresponds to the "push" update operation of the paper, + // not the "push" function in Goldberg's h_prf.c implementation. + // The idea is to push the excess flow from from vertex u to v. + void push_flow(edge_descriptor u_v) + { + vertex_descriptor + u = source(u_v, g), + v = target(u_v, g); + + BOOST_USING_STD_MIN(); + FlowValue flow_delta + = min BOOST_PREVENT_MACRO_SUBSTITUTION(excess_flow[u], residual_capacity[u_v]); + + residual_capacity[u_v] -= flow_delta; + residual_capacity[reverse_edge[u_v]] += flow_delta; + + excess_flow[u] -= flow_delta; + excess_flow[v] += flow_delta; + } // push_flow() + + //======================================================================= + // The main purpose of this routine is to set distance[v] + // to the smallest value allowed by the valid labeling constraints, + // which are: + // distance[t] = 0 + // distance[u] <= distance[v] + 1 for every residual edge (u,v) + // + distance_size_type relabel_distance(vertex_descriptor u) + { + BOOST_USING_STD_MAX(); + ++relabel_count; + work_since_last_update += beta(); + + distance_size_type min_distance = num_vertices(g); + distance[u] = min_distance; + + // Examine the residual out-edges of vertex i, choosing the + // edge whose target vertex has the minimal distance. + out_edge_iterator ai, a_end, min_edge_iter; + for (tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) { + ++work_since_last_update; + edge_descriptor a = *ai; + vertex_descriptor v = target(a, g); + if (is_residual_edge(a) && distance[v] < min_distance) { + min_distance = distance[v]; + min_edge_iter = ai; + } + } + ++min_distance; + if (min_distance < n) { + distance[u] = min_distance; // this is the main action + current[u] = min_edge_iter; + max_distance = max BOOST_PREVENT_MACRO_SUBSTITUTION(min_distance, max_distance); + } + return min_distance; + } // relabel_distance() + + //======================================================================= + // cleanup beyond the gap + void gap(distance_size_type empty_distance) + { + ++gap_count; + + distance_size_type r; // distance of layer before the current layer + r = empty_distance - 1; + + // Set the distance for the vertices beyond the gap to "infinity". + for (layer_iterator l = layers.begin() + empty_distance + 1; + l < layers.begin() + max_distance; ++l) { + list_iterator i; + for (i = l->inactive_vertices.begin(); + i != l->inactive_vertices.end(); ++i) { + distance[*i] = n; + ++gap_node_count; + } + l->inactive_vertices.clear(); + } + max_distance = r; + max_active = r; + } + + //======================================================================= + // This is the core part of the algorithm, "phase one". + FlowValue maximum_preflow() + { + work_since_last_update = 0; + + while (max_active >= min_active) { // "main" loop + + Layer& layer = layers[max_active]; + list_iterator u_iter = layer.active_vertices.begin(); + + if (u_iter == layer.active_vertices.end()) + --max_active; + else { + vertex_descriptor u = *u_iter; + remove_from_active_list(u); + + discharge(u); + + if (work_since_last_update * global_update_frequency() > nm) { + global_distance_update(); + work_since_last_update = 0; + } + } + } // while (max_active >= min_active) + + return excess_flow[sink]; + } // maximum_preflow() + + //======================================================================= + // remove excess flow, the "second phase" + // This does a DFS on the reverse flow graph of nodes with excess flow. + // If a cycle is found, cancel it. + // Return the nodes with excess flow in topological order. + // + // Unlike the prefl_to_flow() implementation, we use + // "color" instead of "distance" for the DFS labels + // "parent" instead of nl_prev for the DFS tree + // "topo_next" instead of nl_next for the topological ordering + void convert_preflow_to_flow() + { + vertex_iterator u_iter, u_end; + out_edge_iterator ai, a_end; + + vertex_descriptor r, restart, u; + + std::vector parent(n); + std::vector topo_next(n); + + vertex_descriptor tos(parent[0]), + bos(parent[0]); // bogus initialization, just to avoid warning + bool bos_null = true; + + // handle self-loops + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) + for (tie(ai, a_end) = out_edges(*u_iter, g); ai != a_end; ++ai) + if (target(*ai, g) == *u_iter) + residual_capacity[*ai] = capacity[*ai]; + + // initialize + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) { + u = *u_iter; + color[u] = ColorTraits::white(); + parent[u] = u; + current[u] = out_edges(u, g).first; + } + // eliminate flow cycles and topologically order the vertices + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) { + u = *u_iter; + if (color[u] == ColorTraits::white() + && excess_flow[u] > 0 + && u != src && u != sink ) { + r = u; + color[r] = ColorTraits::gray(); + while (1) { + for (; current[u] != out_edges(u, g).second; ++current[u]) { + edge_descriptor a = *current[u]; + if (capacity[a] == 0 && is_residual_edge(a)) { + vertex_descriptor v = target(a, g); + if (color[v] == ColorTraits::white()) { + color[v] = ColorTraits::gray(); + parent[v] = u; + u = v; + break; + } else if (color[v] == ColorTraits::gray()) { + // find minimum flow on the cycle + FlowValue delta = residual_capacity[a]; + while (1) { + BOOST_USING_STD_MIN(); + delta = min BOOST_PREVENT_MACRO_SUBSTITUTION(delta, residual_capacity[*current[v]]); + if (v == u) + break; + else + v = target(*current[v], g); + } + // remove delta flow units + v = u; + while (1) { + a = *current[v]; + residual_capacity[a] -= delta; + residual_capacity[reverse_edge[a]] += delta; + v = target(a, g); + if (v == u) + break; + } + + // back-out of DFS to the first saturated edge + restart = u; + for (v = target(*current[u], g); v != u; v = target(a, g)){ + a = *current[v]; + if (color[v] == ColorTraits::white() + || is_saturated(a)) { + color[target(*current[v], g)] = ColorTraits::white(); + if (color[v] != ColorTraits::white()) + restart = v; + } + } + if (restart != u) { + u = restart; + ++current[u]; + break; + } + } // else if (color[v] == ColorTraits::gray()) + } // if (capacity[a] == 0 ... + } // for out_edges(u, g) (though "u" changes during loop) + + if (current[u] == out_edges(u, g).second) { + // scan of i is complete + color[u] = ColorTraits::black(); + if (u != src) { + if (bos_null) { + bos = u; + bos_null = false; + tos = u; + } else { + topo_next[u] = tos; + tos = u; + } + } + if (u != r) { + u = parent[u]; + ++current[u]; + } else + break; + } + } // while (1) + } // if (color[u] == white && excess_flow[u] > 0 & ...) + } // for all vertices in g + + // return excess flows + // note that the sink is not on the stack + if (! bos_null) { + for (u = tos; u != bos; u = topo_next[u]) { + ai = out_edges(u, g).first; + while (excess_flow[u] > 0 && ai != out_edges(u, g).second) { + if (capacity[*ai] == 0 && is_residual_edge(*ai)) + push_flow(*ai); + ++ai; + } + } + // do the bottom + u = bos; + ai = out_edges(u, g).first; + while (excess_flow[u] > 0) { + if (capacity[*ai] == 0 && is_residual_edge(*ai)) + push_flow(*ai); + ++ai; + } + } + + } // convert_preflow_to_flow() + + //======================================================================= + inline bool is_flow() + { + vertex_iterator u_iter, u_end; + out_edge_iterator ai, a_end; + + // check edge flow values + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) { + for (tie(ai, a_end) = out_edges(*u_iter, g); ai != a_end; ++ai) { + edge_descriptor a = *ai; + if (capacity[a] > 0) + if ((residual_capacity[a] + residual_capacity[reverse_edge[a]] + != capacity[a] + capacity[reverse_edge[a]]) + || (residual_capacity[a] < 0) + || (residual_capacity[reverse_edge[a]] < 0)) + return false; + } + } + + // check conservation + FlowValue sum; + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) { + vertex_descriptor u = *u_iter; + if (u != src && u != sink) { + if (excess_flow[u] != 0) + return false; + sum = 0; + for (tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) + if (capacity[*ai] > 0) + sum -= capacity[*ai] - residual_capacity[*ai]; + else + sum += residual_capacity[*ai]; + + if (excess_flow[u] != sum) + return false; + } + } + + return true; + } // is_flow() + + bool is_optimal() { + // check if mincut is saturated... + global_distance_update(); + return distance[src] >= n; + } + + void print_statistics(std::ostream& os) const { + os << "pushes: " << push_count << std::endl + << "relabels: " << relabel_count << std::endl + << "updates: " << update_count << std::endl + << "gaps: " << gap_count << std::endl + << "gap nodes: " << gap_node_count << std::endl + << std::endl; + } + + void print_flow_values(std::ostream& os) const { + os << "flow values" << std::endl; + vertex_iterator u_iter, u_end; + out_edge_iterator ei, e_end; + for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) + for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei) + if (capacity[*ei] > 0) + os << *u_iter << " " << target(*ei, g) << " " + << (capacity[*ei] - residual_capacity[*ei]) << std::endl; + os << std::endl; + } + + //======================================================================= + + Graph& g; + vertices_size_type n; + vertices_size_type nm; + EdgeCapacityMap capacity; + vertex_descriptor src; + vertex_descriptor sink; + VertexIndexMap index; + + // will need to use random_access_property_map with these + std::vector< FlowValue > excess_flow; + std::vector< out_edge_iterator > current; + std::vector< distance_size_type > distance; + std::vector< default_color_type > color; + + // Edge Property Maps that must be interior to the graph + ReverseEdgeMap reverse_edge; + ResidualCapacityEdgeMap residual_capacity; + + LayerArray layers; + std::vector< list_iterator > layer_list_ptr; + distance_size_type max_distance; // maximal distance + distance_size_type max_active; // maximal distance with active node + distance_size_type min_active; // minimal distance with active node + boost::queue Q; + + // Statistics counters + long push_count; + long update_count; + long relabel_count; + long gap_count; + long gap_node_count; + + inline double global_update_frequency() { return 0.5; } + inline vertices_size_type alpha() { return 6; } + inline long beta() { return 12; } + + long work_since_last_update; + }; + + } // namespace detail + + template + typename property_traits::value_type + push_relabel_max_flow + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + CapacityEdgeMap cap, ResidualCapacityEdgeMap res, + ReverseEdgeMap rev, VertexIndexMap index_map) + { + typedef typename property_traits::value_type FlowValue; + + detail::push_relabel + algo(g, cap, res, rev, src, sink, index_map); + + FlowValue flow = algo.maximum_preflow(); + + algo.convert_preflow_to_flow(); + + assert(algo.is_flow()); + assert(algo.is_optimal()); + + return flow; + } // push_relabel_max_flow() + + template + typename detail::edge_capacity_value::type + push_relabel_max_flow + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink, + const bgl_named_params& params) + { + return push_relabel_max_flow + (g, src, sink, + choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity), + choose_pmap(get_param(params, edge_residual_capacity), + g, edge_residual_capacity), + choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index) + ); + } + + template + typename property_traits< + typename property_map::const_type + >::value_type + push_relabel_max_flow + (Graph& g, + typename graph_traits::vertex_descriptor src, + typename graph_traits::vertex_descriptor sink) + { + bgl_named_params params(0); // bogus empty param + return push_relabel_max_flow(g, src, sink, params); + } + +} // namespace boost + +#endif // BOOST_PUSH_RELABEL_MAX_FLOW_HPP + diff --git a/deal.II/contrib/boost/include/boost/graph/random.hpp b/deal.II/contrib/boost/include/boost/graph/random.hpp new file mode 100644 index 0000000000..f25542d865 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/random.hpp @@ -0,0 +1,196 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Copyright (C) Vladimir Prus 2003 +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_RANDOM_HPP +#define BOOST_GRAPH_RANDOM_HPP + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include + +namespace boost { + + // grab a random vertex from the graph's vertex set + template + typename graph_traits::vertex_descriptor + random_vertex(Graph& g, RandomNumGen& gen) + { + if (num_vertices(g) > 1) { + uniform_int<> distrib(0, num_vertices(g)-1); + variate_generator > rand_gen(gen, distrib); + std::size_t n = rand_gen(); + typename graph_traits::vertex_iterator + i = vertices(g).first; + while (n-- > 0) ++i; // std::advance not VC++ portable + return *i; + } else + return *vertices(g).first; + } + + template + typename graph_traits::edge_descriptor + random_edge(Graph& g, RandomNumGen& gen) { + if (num_edges(g) > 1) { + uniform_int<> distrib(0, num_edges(g)-1); + variate_generator > rand_gen(gen, distrib); + typename graph_traits::edges_size_type + n = rand_gen(); + typename graph_traits::edge_iterator + i = edges(g).first; + while (n-- > 0) ++i; // std::advance not VC++ portable + return *i; + } else + return *edges(g).first; + } + + namespace detail { + class dummy_property_copier { + public: + template + void operator()(const V1&, const V2&) const {} + }; + } + + template + void generate_random_graph1 + (MutableGraph& g, + typename graph_traits::vertices_size_type V, + typename graph_traits::vertices_size_type E, + RandNumGen& gen, + bool allow_parallel = true, + bool self_edges = false) + { + typedef graph_traits Traits; + typedef typename Traits::vertices_size_type v_size_t; + typedef typename Traits::edges_size_type e_size_t; + typedef typename Traits::vertex_descriptor vertex_descriptor; + + // When parallel edges are not allowed, we create a new graph which + // does not allow parallel edges, construct it and copy back. + // This is not efficient if 'g' already disallow parallel edges, + // but that's task for later. + if (!allow_parallel) { + + typedef typename boost::graph_traits::directed_category dir; + typedef typename mpl::if_, + directedS, undirectedS>::type select; + adjacency_list g2; + generate_random_graph1(g2, V, E, gen, true, self_edges); + + copy_graph(g2, g, vertex_copy(detail::dummy_property_copier()). + edge_copy(detail::dummy_property_copier())); + + } else { + + for (v_size_t i = 0; i < V; ++i) + add_vertex(g); + + for (e_size_t j = 0; j < E; ++j) { + vertex_descriptor a = random_vertex(g, gen), b; + do { + b = random_vertex(g, gen); + } while (self_edges == false && a == b); + add_edge(a, b, g); + } + } + } + + template + void generate_random_graph + (MutableGraph& g, + typename graph_traits::vertices_size_type V, + typename graph_traits::vertices_size_type E, + RandNumGen& gen, + bool allow_parallel = true, + bool self_edges = false) + { + generate_random_graph1(g, V, E, gen, allow_parallel, self_edges); + } + + template + void generate_random_graph + (MutableGraph& g, + typename graph_traits::vertices_size_type V, + typename graph_traits::vertices_size_type E, + RandNumGen& gen, + VertexOutputIterator vertex_out, + EdgeOutputIterator edge_out, + bool self_edges = false) + { + typedef graph_traits Traits; + typedef typename Traits::vertices_size_type v_size_t; + typedef typename Traits::edges_size_type e_size_t; + typedef typename Traits::vertex_descriptor vertex_t; + typedef typename Traits::edge_descriptor edge_t; + + for (v_size_t i = 0; i < V; ++i) + *vertex_out++ = add_vertex(g); + + for (e_size_t j = 0; j < E; ++j) { + vertex_t a = random_vertex(g, gen), b; + do { + b = random_vertex(g, gen); + } while (self_edges == false && a == b); + edge_t e; bool inserted; + tie(e, inserted) = add_edge(a, b, g); + if (inserted) + *edge_out++ = std::make_pair(source(e, g), target(e, g)); + } + } + + namespace detail { + + template + void randomize_property(G& g, RandomGenerator& rg, + Property, vertex_property_tag) + { + typename property_map::type pm = get(Property(), g); + typename graph_traits::vertex_iterator vi, ve; + for (tie(vi, ve) = vertices(g); vi != ve; ++vi) { + pm[*vi] = rg(); + } + } + + template + void randomize_property(G& g, RandomGenerator& rg, + Property, edge_property_tag) + { + typename property_map::type pm = get(Property(), g); + typename graph_traits::edge_iterator ei, ee; + for (tie(ei, ee) = edges(g); ei != ee; ++ei) { + pm[*ei] = rg(); + } + } + } + + template + void randomize_property(G& g, RandomGenerator& rg) + { + detail::randomize_property + (g, rg, Property(), typename property_kind::type()); + } + + + + +} + + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/random_layout.hpp b/deal.II/contrib/boost/include/boost/graph/random_layout.hpp new file mode 100644 index 0000000000..7f2161221c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/random_layout.hpp @@ -0,0 +1,49 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_RANDOM_LAYOUT_HPP +#define BOOST_GRAPH_RANDOM_LAYOUT_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + +template +void +random_graph_layout(const Graph& g, PositionMap position_map, + Dimension minX, Dimension maxX, + Dimension minY, Dimension maxY, + RandomNumberGenerator& gen) +{ + typedef typename mpl::if_, + uniform_int, + uniform_real >::type distrib_t; + typedef typename mpl::if_, + RandomNumberGenerator&, + uniform_01 > + ::type gen_t; + + gen_t my_gen(gen); + distrib_t x(minX, maxX); + distrib_t y(minY, maxY); + typename graph_traits::vertex_iterator vi, vi_end; + for(tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) { + position_map[*vi].x = x(my_gen); + position_map[*vi].y = y(my_gen); + } +} + +} // end namespace boost + +#endif // BOOST_GRAPH_RANDOM_LAYOUT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/read_dimacs.hpp b/deal.II/contrib/boost/include/boost/graph/read_dimacs.hpp new file mode 100644 index 0000000000..5f4cfe3ca1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/read_dimacs.hpp @@ -0,0 +1,278 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Jeremy G. Siek, Andrew Lumsdaine, Lie-Quan Lee +// +// 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) +//======================================================================= + +/* + Reads maximal flow problem in extended DIMACS format. + + Reads from stdin. + + This works, but could use some polishing. +*/ + +/* ----------------------------------------------------------------- */ + +#include +#include + +namespace boost { + +template +int read_dimacs_max_flow(Graph& g, + CapacityMap capacity, + ReverseEdgeMap reverse_edge, + typename graph_traits::vertex_descriptor& src, + typename graph_traits::vertex_descriptor& sink) +{ + // const int MAXLINE = 100; /* max line length in the input file */ + const int ARC_FIELDS = 3; /* no of fields in arc line */ + const int NODE_FIELDS = 2; /* no of fields in node line */ + const int P_FIELDS = 3; /* no of fields in problem line */ + const char* PROBLEM_TYPE = "max"; /* name of problem type*/ + + typedef typename graph_traits::vertices_size_type vertices_size_type; + typedef typename graph_traits::vertex_descriptor vertex_descriptor; + typedef typename graph_traits::edge_descriptor edge_descriptor; + + std::vector verts; + + long m, n, /* number of edges and nodes */ + i, head, tail, cap; + + long no_lines=0, /* no of current input line */ + no_plines=0, /* no of problem-lines */ + no_nslines=0, /* no of node-source-lines */ + no_nklines=0, /* no of node-source-lines */ + no_alines=0; /* no of arc-lines */ + + std::string in_line; /* for reading input line */ + char pr_type[3]; /* for reading type of the problem */ + char nd; /* source (s) or sink (t) */ + + int k, /* temporary */ + err_no; /* no of detected error */ + + /* -------------- error numbers & error messages ---------------- */ + const int EN1 = 0; + const int EN2 = 1; + const int EN3 = 2; + const int EN4 = 3; + // const int EN6 = 4; + // const int EN10 = 5; + // const int EN7 = 6; + const int EN8 = 7; + const int EN9 = 8; + const int EN11 = 9; + const int EN12 = 10; + // const int EN13 = 11; + const int EN14 = 12; + const int EN16 = 13; + const int EN15 = 14; + const int EN17 = 15; + const int EN18 = 16; + const int EN21 = 17; + const int EN19 = 18; + const int EN20 = 19; + const int EN22 = 20; + + static char *err_message[] = + { + /* 0*/ "more than one problem line.", + /* 1*/ "wrong number of parameters in the problem line.", + /* 2*/ "it is not a Max Flow problem line.", + /* 3*/ "bad value of a parameter in the problem line.", + /* 4*/ "can't obtain enough memory to solve this problem.", + /* 5*/ "more than one line with the problem name.", + /* 6*/ "can't read problem name.", + /* 7*/ "problem description must be before node description.", + /* 8*/ "this parser doesn't support multiply sources and sinks.", + /* 9*/ "wrong number of parameters in the node line.", + /*10*/ "wrong value of parameters in the node line.", + /*11*/ " ", + /*12*/ "source and sink descriptions must be before arc descriptions.", + /*13*/ "too many arcs in the input.", + /*14*/ "wrong number of parameters in the arc line.", + /*15*/ "wrong value of parameters in the arc line.", + /*16*/ "unknown line type in the input.", + /*17*/ "reading error.", + /*18*/ "not enough arcs in the input.", + /*19*/ "source or sink doesn't have incident arcs.", + /*20*/ "can't read anything from the input file." + }; + /* --------------------------------------------------------------- */ + + /* The main loop: + - reads the line of the input, + - analyses its type, + - checks correctness of parameters, + - puts data to the arrays, + - does service functions + */ + + while (std::getline(std::cin, in_line)) { + ++no_lines; + + switch (in_line[0]) { + case 'c': /* skip lines with comments */ + case '\n': /* skip empty lines */ + case '\0': /* skip empty lines at the end of file */ + break; + + case 'p': /* problem description */ + if ( no_plines > 0 ) + /* more than one problem line */ + { err_no = EN1 ; goto error; } + + no_plines = 1; + + if ( + /* reading problem line: type of problem, no of nodes, no of arcs */ + sscanf ( in_line.c_str(), "%*c %3s %ld %ld", pr_type, &n, &m ) + != P_FIELDS + ) + /*wrong number of parameters in the problem line*/ + { err_no = EN2; goto error; } + + if ( strcmp ( pr_type, PROBLEM_TYPE ) ) + /*wrong problem type*/ + { err_no = EN3; goto error; } + + if ( n <= 0 || m <= 0 ) + /*wrong value of no of arcs or nodes*/ + { err_no = EN4; goto error; } + + { + for (long vi = 0; vi < n; ++vi) + verts.push_back(add_vertex(g)); + } + break; + + case 'n': /* source(s) description */ + if ( no_plines == 0 ) + /* there was not problem line above */ + { err_no = EN8; goto error; } + + /* reading source or sink */ + k = sscanf ( in_line.c_str(),"%*c %ld %c", &i, &nd ); + --i; // index from 0 + if ( k < NODE_FIELDS ) + /* node line is incorrect */ + { err_no = EN11; goto error; } + + if ( i < 0 || i > n ) + /* wrong value of node */ + { err_no = EN12; goto error; } + + switch (nd) { + case 's': /* source line */ + + if ( no_nslines != 0) + /* more than one source line */ + { err_no = EN9; goto error; } + + no_nslines = 1; + src = verts[i]; + break; + + case 't': /* sink line */ + + if ( no_nklines != 0) + /* more than one sink line */ + { err_no = EN9; goto error; } + + no_nklines = 1; + sink = verts[i]; + break; + + default: + /* wrong type of node-line */ + err_no = EN12; goto error; + } + break; + + case 'a': /* arc description */ + if ( no_nslines == 0 || no_nklines == 0 ) + /* there was not source and sink description above */ + { err_no = EN14; goto error; } + + if ( no_alines >= m ) + /*too many arcs on input*/ + { err_no = EN16; goto error; } + + if ( + /* reading an arc description */ + sscanf ( in_line.c_str(),"%*c %ld %ld %ld", + &tail, &head, &cap ) + != ARC_FIELDS + ) + /* arc description is not correct */ + { err_no = EN15; goto error; } + + --tail; // index from 0, not 1 + --head; + if ( tail < 0 || tail > n || + head < 0 || head > n + ) + /* wrong value of nodes */ + { err_no = EN17; goto error; } + + { + edge_descriptor e1, e2; + bool in1, in2; + tie(e1, in1) = add_edge(verts[tail], verts[head], g); + tie(e2, in2) = add_edge(verts[head], verts[tail], g); + if (!in1 || !in2) { + std::cerr << "unable to add edge (" << head << "," << tail << ")" + << std::endl; + return -1; + } + capacity[e1] = cap; + capacity[e2] = 0; + reverse_edge[e1] = e2; + reverse_edge[e2] = e1; + } + ++no_alines; + break; + + default: + /* unknown type of line */ + err_no = EN18; goto error; + + } /* end of switch */ + } /* end of input loop */ + + /* ----- all is red or error while reading ----- */ + + if ( feof (stdin) == 0 ) /* reading error */ + { err_no=EN21; goto error; } + + if ( no_lines == 0 ) /* empty input */ + { err_no = EN22; goto error; } + + if ( no_alines < m ) /* not enough arcs */ + { err_no = EN19; goto error; } + + if ( out_degree(src, g) == 0 || out_degree(sink, g) == 0 ) + /* no arc goes out of the source */ + { err_no = EN20; goto error; } + + /* Thanks God! all is done */ + return (0); + + /* ---------------------------------- */ + error: /* error found reading input */ + + printf ( "\nline %ld of input - %s\n", + no_lines, err_message[err_no] ); + + exit (1); + return (0); /* to avoid warning */ +} +/* -------------------- end of parser -------------------*/ + +} // namespace boost diff --git a/deal.II/contrib/boost/include/boost/graph/relax.hpp b/deal.II/contrib/boost/include/boost/graph/relax.hpp new file mode 100644 index 0000000000..74b3261e00 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/relax.hpp @@ -0,0 +1,99 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// + +#ifndef BOOST_GRAPH_RELAX_HPP +#define BOOST_GRAPH_RELAX_HPP + +#include +#include // for numeric limits +#include +#include + +namespace boost { + + // The following version of the plus functor prevents + // problems due to overflow at positive infinity. + + template + struct closed_plus + { + // std::abs just isn't portable :( + template + inline X my_abs(const X& x) const { return x < 0 ? -x : x; } + + T operator()(const T& a, const T& b) const { + using namespace std; + T inf = (numeric_limits::max)(); + if (b > 0 && my_abs(inf - a) < b) + return inf; + return a + b; + } + }; + + template + bool relax(typename graph_traits::edge_descriptor e, + const Graph& g, const WeightMap& w, + PredecessorMap& p, DistanceMap& d, + const BinaryFunction& combine, const BinaryPredicate& compare) + { + typedef typename graph_traits::directed_category DirCat; + bool is_undirected = is_same::value; + typedef typename graph_traits::vertex_descriptor Vertex; + Vertex u = source(e, g), v = target(e, g); + typedef typename property_traits::value_type D; + typedef typename property_traits::value_type W; + D d_u = get(d, u), d_v = get(d, v); + W w_e = get(w, e); + + if ( compare(combine(d_u, w_e), d_v) ) { + put(d, v, combine(d_u, w_e)); + put(p, v, u); + return true; + } else if (is_undirected && compare(combine(d_v, w_e), d_u)) { + put(d, u, combine(d_v, w_e)); + put(p, u, v); + return true; + } else + return false; + } + + template + bool relax(typename graph_traits::edge_descriptor e, + const Graph& g, WeightMap w, PredecessorMap p, DistanceMap d) + { + typedef typename property_traits::value_type D; + typedef closed_plus Combine; + typedef std::less Compare; + return relax(e, g, w, p, d, Combine(), Compare()); + } + +} // namespace boost + +#endif /* BOOST_GRAPH_RELAX_HPP */ diff --git a/deal.II/contrib/boost/include/boost/graph/reverse_graph.hpp b/deal.II/contrib/boost/include/boost/graph/reverse_graph.hpp new file mode 100644 index 0000000000..06c135ffb6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/reverse_graph.hpp @@ -0,0 +1,314 @@ +// (C) Copyright David Abrahams 2000. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef REVERSE_GRAPH_DWA092300_H_ +# define REVERSE_GRAPH_DWA092300_H_ + +#include +#include +#include + +namespace boost { + +struct reverse_graph_tag { }; + + namespace detail { + + template struct choose_rev_edge_iter { }; + template <> struct choose_rev_edge_iter { + template struct bind_ { + typedef typename graph_traits::edge_iterator type; + }; + }; + template <> struct choose_rev_edge_iter { + template struct bind_ { + typedef void type; + }; + }; + + } // namespace detail + +template +class reverse_graph { + typedef reverse_graph Self; + typedef graph_traits Traits; + public: + typedef BidirectionalGraph base_type; + + // Constructor + reverse_graph(GraphRef g) : m_g(g) {} + + // Graph requirements + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + typedef typename Traits::directed_category directed_category; + typedef typename Traits::edge_parallel_category edge_parallel_category; + typedef typename Traits::traversal_category traversal_category; + + // IncidenceGraph requirements + typedef typename Traits::in_edge_iterator out_edge_iterator; + typedef typename Traits::degree_size_type degree_size_type; + + // BidirectionalGraph requirements + typedef typename Traits::out_edge_iterator in_edge_iterator; + + // AdjacencyGraph requirements + typedef typename adjacency_iterator_generator::type adjacency_iterator; + + // VertexListGraph requirements + typedef typename Traits::vertex_iterator vertex_iterator; + + // EdgeListGraph requirements + enum { is_edge_list = is_convertible::value }; + typedef detail::choose_rev_edge_iter ChooseEdgeIter; + typedef typename ChooseEdgeIter:: + template bind_::type edge_iterator; + typedef typename Traits::vertices_size_type vertices_size_type; + typedef typename Traits::edges_size_type edges_size_type; + + // More typedefs used by detail::edge_property_map, vertex_property_map + typedef typename BidirectionalGraph::edge_property_type + edge_property_type; + typedef typename BidirectionalGraph::vertex_property_type + vertex_property_type; + typedef reverse_graph_tag graph_tag; + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + // Bundled properties support + template + typename graph::detail::bundled_result::type& + operator[](Descriptor x) + { return m_g[x]; } + + template + typename graph::detail::bundled_result::type const& + operator[](Descriptor x) const + { return m_g[x]; } +#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES + + static vertex_descriptor null_vertex() + { return Traits::null_vertex(); } + + // would be private, but template friends aren't portable enough. + // private: + GraphRef m_g; +}; + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + template + struct vertex_bundle_type > + : vertex_bundle_type { }; + + template + struct edge_bundle_type > + : edge_bundle_type { }; +#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES + +template +inline reverse_graph +make_reverse_graph(const BidirectionalGraph& g) +{ + return reverse_graph(g); +} + +template +inline reverse_graph +make_reverse_graph(BidirectionalGraph& g) +{ + return reverse_graph(g); +} + +template +std::pair::vertex_iterator, + typename reverse_graph::vertex_iterator> +vertices(const reverse_graph& g) +{ + return vertices(g.m_g); +} + +template +std::pair::edge_iterator, + typename reverse_graph::edge_iterator> +edges(const reverse_graph& g) +{ + return edges(g.m_g); +} + +template +inline std::pair +out_edges(const typename BidirectionalGraph::vertex_descriptor u, + const reverse_graph& g) +{ + return in_edges(u, g.m_g); +} + +template +inline typename BidirectionalGraph::vertices_size_type +num_vertices(const reverse_graph& g) +{ + return num_vertices(g.m_g); +} + +template +inline typename reverse_graph::edges_size_type +num_edges(const reverse_graph& g) +{ + return num_edges(g.m_g); +} + +template +inline typename BidirectionalGraph::degree_size_type +out_degree(const typename BidirectionalGraph::vertex_descriptor u, + const reverse_graph& g) +{ + return in_degree(u, g.m_g); +} + +template +inline std::pair +edge(const typename BidirectionalGraph::vertex_descriptor u, + const typename BidirectionalGraph::vertex_descriptor v, + const reverse_graph& g) +{ + return edge(v, u, g.m_g); +} + +template +inline std::pair +in_edges(const typename BidirectionalGraph::vertex_descriptor u, + const reverse_graph& g) +{ + return out_edges(u, g.m_g); +} + +template +inline std::pair::adjacency_iterator, + typename reverse_graph::adjacency_iterator> +adjacent_vertices(const typename BidirectionalGraph::vertex_descriptor u, + const reverse_graph& g) +{ + typedef reverse_graph Graph; + typename Graph::out_edge_iterator first, last; + tie(first, last) = out_edges(u, g); + typedef typename Graph::adjacency_iterator adjacency_iterator; + return std::make_pair(adjacency_iterator(first, const_cast(&g)), + adjacency_iterator(last, const_cast(&g))); +} + +template +inline typename BidirectionalGraph::degree_size_type +in_degree(const typename BidirectionalGraph::vertex_descriptor u, + const reverse_graph& g) +{ + return out_degree(u, g.m_g); +} + +template +inline typename graph_traits::vertex_descriptor +source(const Edge& e, const reverse_graph& g) +{ + return target(e, g.m_g); +} + +template +inline typename graph_traits::vertex_descriptor +target(const Edge& e, const reverse_graph& g) +{ + return source(e, g.m_g); +} + + +namespace detail { + + struct reverse_graph_vertex_property_selector { + template + struct bind_ { + typedef typename ReverseGraph::base_type Graph; + typedef property_map PMap; + typedef typename PMap::type type; + typedef typename PMap::const_type const_type; + }; + }; + + struct reverse_graph_edge_property_selector { + template + struct bind_ { + typedef typename ReverseGraph::base_type Graph; + typedef property_map PMap; + typedef typename PMap::type type; + typedef typename PMap::const_type const_type; + }; + }; + +} // namespace detail + +template <> +struct vertex_property_selector { + typedef detail::reverse_graph_vertex_property_selector type; +}; + +template <> +struct edge_property_selector { + typedef detail::reverse_graph_edge_property_selector type; +}; + +template +typename property_map::type +get(Property p, reverse_graph& g) +{ + return get(p, g.m_g); +} + +template +typename property_map::const_type +get(Property p, const reverse_graph& g) +{ + const BidirGraph& gref = g.m_g; // in case GRef is non-const + return get(p, gref); +} + +template +typename property_traits< + typename property_map::const_type +>::value_type +get(Property p, const reverse_graph& g, const Key& k) +{ + return get(p, g.m_g, k); +} + +template +void +put(Property p, const reverse_graph& g, const Key& k, + const Value& val) +{ + put(p, g.m_g, k, val); +} + +template +inline void +set_property(const reverse_graph& g, Tag tag, + const Value& value) +{ + set_property(g.m_g, tag, value); +} + +template +inline +typename graph_property::type +get_property(const reverse_graph& g, Tag tag) +{ + return get_property(g.m_g, tag); +} + +} // namespace boost + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/sequential_vertex_coloring.hpp b/deal.II/contrib/boost/include/boost/graph/sequential_vertex_coloring.hpp new file mode 100644 index 0000000000..606f2e52d2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/sequential_vertex_coloring.hpp @@ -0,0 +1,124 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Copyright 2004 The Trustees of Indiana University +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_SEQUENTIAL_VERTEX_COLORING_HPP +#define BOOST_GRAPH_SEQUENTIAL_VERTEX_COLORING_HPP + +#include +#include +#include +#include +#include + +#ifdef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# include +#endif + +/* This algorithm is to find coloring of a graph + + Algorithm: + Let G = (V,E) be a graph with vertices (somehow) ordered v_1, v_2, ..., + v_n. For k = 1, 2, ..., n the sequential algorithm assigns v_k to the + smallest possible color. + + Reference: + + Thomas F. Coleman and Jorge J. More, Estimation of sparse Jacobian + matrices and graph coloring problems. J. Numer. Anal. V20, P187-209, 1983 + + v_k is stored as o[k] here. + + The color of the vertex v will be stored in color[v]. + i.e., vertex v belongs to coloring color[v] */ + +namespace boost { + template + typename property_traits::value_type + sequential_vertex_coloring(const VertexListGraph& G, OrderPA order, + ColorMap color) + { + typedef graph_traits GraphTraits; + typedef typename GraphTraits::vertex_descriptor Vertex; + typedef typename property_traits::value_type size_type; + + size_type max_color = 0; + const size_type V = num_vertices(G); + + // We need to keep track of which colors are used by + // adjacent vertices. We do this by marking the colors + // that are used. The mark array contains the mark + // for each color. The length of mark is the + // number of vertices since the maximum possible number of colors + // is the number of vertices. + std::vector mark(V, + std::numeric_limits::max BOOST_PREVENT_MACRO_SUBSTITUTION()); + + //Initialize colors + typename GraphTraits::vertex_iterator v, vend; + for (tie(v, vend) = vertices(G); v != vend; ++v) + put(color, *v, V-1); + + //Determine the color for every vertex one by one + for ( size_type i = 0; i < V; i++) { + Vertex current = get(order,i); + typename GraphTraits::adjacency_iterator v, vend; + + //Mark the colors of vertices adjacent to current. + //i can be the value for marking since i increases successively + for (tie(v,vend) = adjacent_vertices(current, G); v != vend; ++v) + mark[get(color,*v)] = i; + + //Next step is to assign the smallest un-marked color + //to the current vertex. + size_type j = 0; + + //Scan through all useable colors, find the smallest possible + //color that is not used by neighbors. Note that if mark[j] + //is equal to i, color j is used by one of the current vertex's + //neighbors. + while ( j < max_color && mark[j] == i ) + ++j; + + if ( j == max_color ) //All colors are used up. Add one more color + ++max_color; + + //At this point, j is the smallest possible color + put(color, current, j); //Save the color of vertex current + } + + return max_color; + } + + template + typename property_traits::value_type + sequential_vertex_coloring(const VertexListGraph& G, ColorMap color) + { + typedef typename graph_traits::vertex_descriptor + vertex_descriptor; + typedef typename graph_traits::vertex_iterator + vertex_iterator; + + std::pair v = vertices(G); +#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS + std::vector order(v.first, v.second); +#else + std::vector order; + order.reserve(std::distance(v.first, v.second)); + while (v.first != v.second) order.push_back(*v.first++); +#endif + return sequential_vertex_coloring + (G, + make_iterator_property_map + (order.begin(), identity_property_map(), + graph_traits::null_vertex()), + color); + } +} + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/simple_point.hpp b/deal.II/contrib/boost/include/boost/graph/simple_point.hpp new file mode 100644 index 0000000000..915f4f7ce9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/simple_point.hpp @@ -0,0 +1,15 @@ +#ifndef BOOST_GRAPH_SIMPLE_POINT_HPP +#define BOOST_GRAPH_SIMPLE_POINT_HPP + +namespace boost { + +template +struct simple_point +{ + T x; + T y; +}; + +} // end namespace boost + +#endif // BOOST_GRAPH_SIMPLE_POINT_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/sloan_ordering.hpp b/deal.II/contrib/boost/include/boost/graph/sloan_ordering.hpp new file mode 100755 index 0000000000..0ceac6cf13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/sloan_ordering.hpp @@ -0,0 +1,464 @@ +// +//======================================================================= +// Copyright 2002 Marc Wintermantel (wintermantel@imes.mavt.ethz.ch) +// ETH Zurich, Center of Structure Technologies (www.imes.ethz.ch/st) +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// + +#ifndef BOOST_GRAPH_SLOAN_HPP +#define BOOST_GRAPH_SLOAN_HPP + +#define WEIGHT1 1 //default weight for the distance in the Sloan algorithm +#define WEIGHT2 2 //default weight for the degree in the Sloan algorithm +#define MAXINT 2147483647 //Maximum value for a 32bit integer + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +//////////////////////////////////////////////////////////// +// +//Sloan-Algorithm for graph reordering +//(optimzes profile and wavefront, not primiraly bandwidth +// +//////////////////////////////////////////////////////////// + +namespace boost { + + ///////////////////////////////////////////////////////////////////////// + // Function that returns the maximum depth of + // a rooted level strucutre (RLS) + // + ///////////////////////////////////////////////////////////////////////// + template + unsigned RLS_depth(Distance& d) + { + unsigned h_s = 0; + typename Distance::iterator iter; + + for (iter = d.begin(); iter != d.end(); ++iter) + { + if(*iter > h_s) + { + h_s = *iter; + } + } + + return h_s; + } + + + + ///////////////////////////////////////////////////////////////////////// + // Function that returns the width of the largest level of + // a rooted level strucutre (RLS) + // + ///////////////////////////////////////////////////////////////////////// + template + unsigned RLS_max_width(Distance& d, my_int depth) + { + + //Searching for the maximum width of a level + std::vector dummy_width(depth+1, 0); + std::vector::iterator my_it; + typename Distance::iterator iter; + unsigned w_max = 0; + + for (iter = d.begin(); iter != d.end(); ++iter) + { + dummy_width[*iter]++; + } + + for(my_it = dummy_width.begin(); my_it != dummy_width.end(); ++my_it) + { + if(*my_it > w_max) w_max = *my_it; + } + + return w_max; + + } + + + ///////////////////////////////////////////////////////////////////////// + // Function for finding a good starting node for Sloan algorithm + // + // This is to find a good starting node. "good" is in the sense + // of the ordering generated. + ///////////////////////////////////////////////////////////////////////// + template + typename graph_traits::vertex_descriptor + sloan_start_end_vertices(Graph& G, + typename graph_traits::vertex_descriptor &s, + ColorMap color, + DegreeMap degree) + { + typedef typename property_traits::value_type Degree; + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename std::vector< typename graph_traits::vertices_size_type>::iterator vec_iter; + typedef typename graph_traits::vertices_size_type size_type; + + typedef typename property_map::const_type VertexID; + + s = *(vertices(G).first); + Vertex e = s; + Vertex i; + unsigned my_degree = get(degree, s ); + unsigned dummy, h_i, h_s, w_i, w_e; + bool new_start = true; + unsigned maximum_degree = 0; + + //Creating a std-vector for storing the distance from the start vertex in dist + std::vector::vertices_size_type> dist(num_vertices(G), 0); + + //Wrap a property_map_iterator around the std::iterator + boost::iterator_property_map dist_pmap(dist.begin(), get(vertex_index, G)); + + //Creating a property_map for the indices of a vertex + typename property_map::type index_map = get(vertex_index, G); + + //Creating a priority queue + typedef indirect_cmp > Compare; + Compare comp(degree); + std::priority_queue, Compare> degree_queue(comp); + + //step 1 + //Scan for the vertex with the smallest degree and the maximum degree + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) + { + dummy = get(degree, *ui); + + if(dummy < my_degree) + { + my_degree = dummy; + s = *ui; + } + + if(dummy > maximum_degree) + { + maximum_degree = dummy; + } + } + //end 1 + + do{ + new_start = false; //Setting the loop repetition status to false + + //step 2 + //initialize the the disance std-vector with 0 + for(typename std::vector::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0; + + //generating the RLS (rooted level structure) + breadth_first_search + (G, s, visitor + ( + make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) + ) + ); + + //end 2 + + //step 3 + //calculating the depth of the RLS + h_s = RLS_depth(dist); + + //step 4 + //pushing one node of each degree in an ascending manner into degree_queue + std::vector shrink_trace(maximum_degree, false); + for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) + { + dummy = get(degree, *ui); + + if( (dist[index_map[*ui]] == h_s ) && ( !shrink_trace[ dummy ] ) ) + { + degree_queue.push(*ui); + shrink_trace[ dummy ] = true; + } + } + + //end 3 & 4 + + + //step 5 + //Initializing w + w_e = MAXINT; + //end 5 + + + //step 6 + //Testing for termination + while( !degree_queue.empty() ) + { + i = degree_queue.top(); //getting the node with the lowest degree from the degree queue + degree_queue.pop(); //ereasing the node with the lowest degree from the degree queue + + //generating a RLS + for(typename std::vector::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0; + + breadth_first_search + (G, i, boost::visitor + ( + make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) + ) + ); + + //Calculating depth and width of the rooted level + h_i = RLS_depth(dist); + w_i = RLS_max_width(dist, h_i); + + //Testing for termination + if( (h_i > h_s) && (w_i < w_e) ) + { + h_s = h_i; + s = i; + while(!degree_queue.empty()) degree_queue.pop(); + new_start = true; + } + else if(w_i < w_e) + { + w_e = w_i; + e = i; + } + } + //end 6 + + }while(new_start); + + return e; + } + + ////////////////////////////////////////////////////////////////////////// + // Sloan algorithm with a given starting Vertex. + // + // This algorithm requires user to provide a starting vertex to + // compute Sloan ordering. + ////////////////////////////////////////////////////////////////////////// + template + OutputIterator + sloan_ordering(Graph& g, + typename graph_traits::vertex_descriptor s, + typename graph_traits::vertex_descriptor e, + OutputIterator permutation, + ColorMap color, + DegreeMap degree, + PriorityMap priority, + Weight W1, + Weight W2) + { + //typedef typename property_traits::value_type Degree; + typedef typename property_traits::value_type Degree; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename std::vector::vertices_size_type>::iterator vec_iter; + typedef typename graph_traits::vertices_size_type size_type; + + typedef typename property_map::const_type VertexID; + + + //Creating a std-vector for storing the distance from the end vertex in it + typename std::vector::vertices_size_type> dist(num_vertices(g), 0); + + //Wrap a property_map_iterator around the std::iterator + boost::iterator_property_map dist_pmap(dist.begin(), get(vertex_index, g)); + + breadth_first_search + (g, e, visitor + ( + make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) + ) + ); + + //Creating a property_map for the indices of a vertex + typename property_map::type index_map = get(vertex_index, g); + + //Sets the color and priority to their initial status + unsigned cdeg; + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) + { + put(color, *ui, Color::white()); + cdeg=get(degree, *ui)+1; + put(priority, *ui, W1*dist[index_map[*ui]]-W2*cdeg ); + } + + //Priority list + typedef indirect_cmp > Compare; + Compare comp(priority); + std::list priority_list; + + //Some more declarations + typename graph_traits::out_edge_iterator ei, ei_end, ei2, ei2_end; + Vertex u, v, w; + + put(color, s, Color::green()); //Sets the color of the starting vertex to gray + priority_list.push_front(s); //Puts s into the priority_list + + while ( !priority_list.empty() ) + { + priority_list.sort(comp); //Orders the elements in the priority list in an ascending manner + + u = priority_list.front(); //Accesses the last element in the priority list + priority_list.pop_front(); //Removes the last element in the priority list + + if(get(color, u) == Color::green() ) + { + //for-loop over all out-edges of vertex u + for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) + { + v = target(*ei, g); + + put( priority, v, get(priority, v) + W2 ); //updates the priority + + if (get(color, v) == Color::white() ) //test if the vertex is inactive + { + put(color, v, Color::green() ); //giving the vertex a preactive status + priority_list.push_front(v); //writing the vertex in the priority_queue + } + } + } + + //Here starts step 8 + *permutation++ = u; //Puts u to the first position in the permutation-vector + put(color, u, Color::black() ); //Gives u an inactive status + + //for loop over all the adjacent vertices of u + for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { + + v = target(*ei, g); + + if (get(color, v) == Color::green() ) { //tests if the vertex is inactive + + put(color, v, Color::red() ); //giving the vertex an active status + put(priority, v, get(priority, v)+W2); //updates the priority + + //for loop over alll adjacent vertices of v + for (tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) { + w = target(*ei2, g); + + if(get(color, w) != Color::black() ) { //tests if vertex is postactive + + put(priority, w, get(priority, w)+W2); //updates the priority + + if(get(color, w) == Color::white() ){ + + put(color, w, Color::green() ); // gives the vertex a preactive status + priority_list.push_front(w); // puts the vertex into the priority queue + + } //end if + + } //end if + + } //end for + + } //end if + + } //end for + + } //end while + + + return permutation; + } + + ///////////////////////////////////////////////////////////////////////////////////////// + // Same algorithm as before, but without the weights given (taking default weights + template + OutputIterator + sloan_ordering(Graph& g, + typename graph_traits::vertex_descriptor s, + typename graph_traits::vertex_descriptor e, + OutputIterator permutation, + ColorMap color, + DegreeMap degree, + PriorityMap priority) + { + return sloan_ordering(g, s, e, permutation, color, degree, priority, WEIGHT1, WEIGHT2); + } + + + ////////////////////////////////////////////////////////////////////////// + // Sloan algorithm without a given starting Vertex. + // + // This algorithm finds a good starting vertex itself to + // compute Sloan-ordering. + ////////////////////////////////////////////////////////////////////////// + + + + template < class Graph, class OutputIterator, + class Color, class Degree, + class Priority, class Weight> + inline OutputIterator + sloan_ordering(Graph& G, + OutputIterator permutation, + Color color, + Degree degree, + Priority priority, + Weight W1, + Weight W2 ) + { + typedef typename boost::graph_traits::vertex_descriptor Vertex; + + Vertex s, e; + e = sloan_start_end_vertices(G, s, color, degree); + + return sloan_ordering(G, s, e, permutation, color, degree, priority, W1, W2); + } + + ///////////////////////////////////////////////////////////////////////////////////////// + // Same as before, but without given weights (default weights are taken instead) + template < class Graph, class OutputIterator, + class Color, class Degree, + class Priority > + inline OutputIterator + sloan_ordering(Graph& G, + OutputIterator permutation, + Color color, + Degree degree, + Priority priority) + { + return sloan_ordering(G, permutation, color, degree, priority, WEIGHT1, WEIGHT2); + } + + +} // namespace boost + + +#endif // BOOST_GRAPH_SLOAN_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/small_world_generator.hpp b/deal.II/contrib/boost/include/boost/graph/small_world_generator.hpp new file mode 100644 index 0000000000..9cd62deb7e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/small_world_generator.hpp @@ -0,0 +1,114 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_GRAPH_SMALL_WORLD_GENERATOR_HPP +#define BOOST_GRAPH_SMALL_WORLD_GENERATOR_HPP + +#include +#include +#include +#include + +namespace boost { + + // Assumes undirected + template + class small_world_iterator + { + typedef typename graph_traits::vertices_size_type + vertices_size_type; + + public: + typedef std::input_iterator_tag iterator_category; + typedef std::pair value_type; + typedef const value_type& reference; + typedef const value_type* pointer; + typedef void difference_type; + + small_world_iterator() : gen(0) {} + small_world_iterator(RandomGenerator& gen, vertices_size_type n, + vertices_size_type k, double prob = 0.0, + bool allow_self_loops = false) + : gen(&gen), n(n), k(k), prob(prob), source(0), + target(allow_self_loops? 0 : 1), + allow_self_loops(allow_self_loops), + current(0, allow_self_loops? 0 : 1) + { } + + reference operator*() const { return current; } + pointer operator->() const { return ¤t; } + + small_world_iterator& operator++() + { + target = (target + 1) % n; + if (target == (source + k/2 + 1) % n) { + ++source; + if (allow_self_loops) target = source; + else target = (source + 1) % n; + } + current.first = source; + + uniform_01 rand01(*gen); + uniform_int rand_vertex_gen(0, n-1); + double x = rand01(); + *gen = rand01.base(); // GRRRR + if (x < prob) { + vertices_size_type lower = (source + n - k/2) % n; + vertices_size_type upper = (source + k/2) % n; + do { + current.second = rand_vertex_gen(*gen); + } while (current.second >= lower && current.second <= upper + || (upper < lower + && (current.second >= lower || current.second <= upper))); + } else { + current.second = target; + } + return *this; + } + + small_world_iterator operator++(int) + { + small_world_iterator temp(*this); + ++(*this); + return temp; + } + + bool operator==(const small_world_iterator& other) const + { + if (!gen && other.gen) return other == *this; + else if (gen && !other.gen) return source == n; + else if (!gen && !other.gen) return true; + return source == other.source && target == other.target; + } + + bool operator!=(const small_world_iterator& other) const + { return !(*this == other); } + + private: + void next() + { + uniform_int rand_vertex(0, n-1); + current.first = rand_vertex(*gen); + do { + current.second = rand_vertex(*gen); + } while (current.first == current.second && !allow_self_loops); + } + + RandomGenerator* gen; + vertices_size_type n; + vertices_size_type k; + double prob; + vertices_size_type source; + vertices_size_type target; + bool allow_self_loops; + value_type current; + }; + +} // end namespace boost + +#endif // BOOST_GRAPH_SMALL_WORLD_GENERATOR_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/smallest_last_ordering.hpp b/deal.II/contrib/boost/include/boost/graph/smallest_last_ordering.hpp new file mode 100644 index 0000000000..eea652d046 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/smallest_last_ordering.hpp @@ -0,0 +1,111 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_SMALLEST_LAST_VERTEX_ORDERING_HPP +#define BOOST_SMALLEST_LAST_VERTEX_ORDERING_HPP +/* + The smallest-last ordering is defined for the loopless graph G with + vertices a(j), j = 1,2,...,n where a(j) is the j-th column of A and + with edge (a(i),a(j)) if and only if columns i and j have a + non-zero in the same row position. The smallest-last ordering is + determined recursively by letting list(k), k = n,...,1 be a column + with least degree in the subgraph spanned by the un-ordered + columns. + */ +#include +#include +#include +#include +#include + +namespace boost { + + template + void + smallest_last_vertex_ordering(const VertexListGraph& G, Order order, + Degree degree, Marker marker) { + typedef typename graph_traits GraphTraits; + typedef typename GraphTraits::vertex_descriptor Vertex; + //typedef typename GraphTraits::size_type size_type; + typedef std::size_t size_type; + + const size_type num = num_vertices(G); + + typedef typename vertex_property_map::type ID; + typedef bucket_sorter BucketSorter; + + BucketSorter degree_bucket_sorter(num, num, degree, + get_vertex_property(G, vertex_index)); + + smallest_last_vertex_ordering(G, order, degree, marker, degree_bucket_sorter); + } + + template + void + smallest_last_vertex_ordering(const VertexListGraph& G, Order order, + Degree degree, Marker marker, + BucketSorter& degree_buckets) { + typedef typename graph_traits GraphTraits; + typedef typename GraphTraits::vertex_descriptor Vertex; + //typedef typename GraphTraits::size_type size_type; + typedef std::size_t size_type; + + const size_type num = num_vertices(G); + + typename GraphTraits::vertex_iterator v, vend; + for (boost::tie(v, vend) = vertices(G); v != vend; ++v) { + put(marker, *v, num); + put(degree, *v, out_degree(*v, G)); + degree_buckets.push(*v); + } + + size_type minimum_degree = 1; + size_type current_order = num - 1; + + while ( 1 ) { + typedef typename BucketSorter::stack MDStack; + MDStack minimum_degree_stack = degree_buckets[minimum_degree]; + while (minimum_degree_stack.empty()) + minimum_degree_stack = degree_buckets[++minimum_degree]; + + Vertex node = minimum_degree_stack.top(); + put(order, current_order, node); + + if ( current_order == 0 ) //find all vertices + break; + + minimum_degree_stack.pop(); + put(marker, node, 0); //node has been ordered. + + typename GraphTraits::adjacency_iterator v, vend; + for (boost::tie(v,vend) = adjacent_vertices(node, G); v != vend; ++v) + + if ( get(marker,*v) > current_order ) { //*v is unordered vertex + put(marker, *v, current_order); //mark the columns adjacent to node + + //It is possible minimum degree goes down + //Here we keep tracking it. + put(degree, *v, get(degree, *v) - 1); + BOOST_USING_STD_MIN(); + minimum_degree = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_degree, get(degree, *v)); + + //update the position of *v in the bucket sorter + degree_buckets.update(*v); + } + + current_order--; + } + + //at this point, order[i] = v_i; + } + +} + +#endif + diff --git a/deal.II/contrib/boost/include/boost/graph/stanford_graph.hpp b/deal.II/contrib/boost/include/boost/graph/stanford_graph.hpp new file mode 100644 index 0000000000..c98bba1167 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/stanford_graph.hpp @@ -0,0 +1,565 @@ +//======================================================================= +// Copyright 1997-2001 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_SGB_GRAPH_HPP +#define BOOST_GRAPH_SGB_GRAPH_HPP + +#include +#include +#include +#include +#include +#include + +// Thanks to Andreas Scherer for numerous suggestions and fixes! + +// This file adapts a Stanford GraphBase (SGB) Graph pointer into a +// VertexListGraph. Note that a graph adaptor class is not needed, +// SGB's Graph* is used as is. The VertexListGraph concept is fulfilled by +// defining the appropriate non-member functions for Graph*. +// +// The PROTOTYPES change file extensions to SGB must be applied so +// that the SGB functions have real prototypes which are necessary for +// the C++ compiler. To apply the PROTOTYPES extensions, before you do +// "make tests install" for SGB do "ln -s PROTOTYPES/* ." to the SGB +// root directory (or just copy all the files from the PROTOTYPES +// directory to the SGB root directory). +// +extern "C" { + // We include all global definitions for the general stuff + // of The Stanford GraphBase and its various graph generator + // functions by reading all SGB headerfiles as in section 2 of + // the "test_sample" program. +#include /* SGB data structures */ +#include /* SGB input/output routines */ +#include /* random number generator */ +#include /* routines for shortest paths */ +#include /* the basic graph operations */ +#undef empty /* avoid name clash with C++ standard library */ + inline Graph* empty( long n ) /* and provide workaround */ + { return board(n,0L,0L,0L,2L,0L,0L); } +#include /* graphs based on literature */ +#include /* graphs based on economic data */ +#include /* graphs based on football scores */ +#include /* graphs based on logic circuits */ +#undef val /* avoid name clash with g++ headerfile stl_tempbuf.h */ + // val ==> Vertex::x.I +#include /* graphs based on Mona Lisa */ +#include /* graphs based on mileage data */ +#include /* planar graphs */ +#include /* Ramanujan graphs */ +#include /* random graphs */ +#include /* graphs based on Roget's Thesaurus */ +#include /* we save results in ASCII format */ +#include /* five-letter-word graphs */ +#undef weight /* avoid name clash with BGL parameter */ + // weight ==> Vertex::u.I +} + +namespace boost { + class sgb_edge; +} + +class sgb_out_edge_iterator; +class sgb_adj_iterator; +class sgb_vertex_iterator; + +namespace boost { + typedef Graph* sgb_graph_ptr; + typedef const Graph* sgb_const_graph_ptr; + + struct sgb_traversal_tag : + public virtual vertex_list_graph_tag, + public virtual incidence_graph_tag, + public virtual adjacency_graph_tag { }; + + template <> struct graph_traits { + typedef Vertex* vertex_descriptor; + typedef boost::sgb_edge edge_descriptor; + typedef sgb_out_edge_iterator out_edge_iterator; + typedef void in_edge_iterator; + typedef sgb_adj_iterator adjacency_iterator; + typedef sgb_vertex_iterator vertex_iterator; + typedef void edge_iterator; + typedef long vertices_size_type; + typedef long edge_size_type; + typedef long degree_size_type; + typedef directed_tag directed_category; + typedef sgb_traversal_tag traversal_category; + typedef allow_parallel_edge_tag edge_parallel_category; + }; + template <> struct graph_traits { + typedef Vertex* vertex_descriptor; + typedef boost::sgb_edge edge_descriptor; + typedef sgb_out_edge_iterator out_edge_iterator; + typedef void in_edge_iterator; + typedef sgb_adj_iterator adjacency_iterator; + typedef sgb_vertex_iterator vertex_iterator; + typedef void edge_iterator; + typedef long vertices_size_type; + typedef long edge_size_type; + typedef long degree_size_type; + typedef directed_tag directed_category; + typedef sgb_traversal_tag traversal_category; + typedef allow_parallel_edge_tag edge_parallel_category; + }; +} + +namespace boost { + + struct edge_length_t { + typedef edge_property_tag kind; + }; + + // We could just use Arc* as the edge descriptor type, but + // we want to add the source(e,g) function which requires + // that we carry along a pointer to the source vertex. + class sgb_edge { + typedef sgb_edge self; + public: + sgb_edge() : _arc(0), _src(0) { } + sgb_edge(Arc* a, Vertex* s) : _arc(a), _src(s) { } + friend Vertex* source(self e, sgb_const_graph_ptr) { return e._src; } + friend Vertex* target(self e, sgb_const_graph_ptr) { return e._arc->tip; } + friend bool operator==(const self& a, const self& b) { + return a._arc == b._arc; } + friend bool operator!=(const self& a, const self& b) { + return a._arc != b._arc; } +#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + template friend class sgb_edge_length_map; + template friend class sgb_edge_util_map; + friend long get(edge_length_t, const sgb_graph_ptr&, const sgb_edge& key); + friend long get(edge_length_t, const sgb_const_graph_ptr&, const sgb_edge& key); + friend void put(edge_length_t, sgb_graph_ptr&, const sgb_edge& key, long value); + protected: +#endif + Arc* _arc; + Vertex* _src; + }; +} // namespace boost + + class sgb_out_edge_iterator + : public boost::forward_iterator_helper< + sgb_out_edge_iterator, boost::sgb_edge, + std::ptrdiff_t, boost::sgb_edge*, boost::sgb_edge> + { + typedef sgb_out_edge_iterator self; + public: + sgb_out_edge_iterator() : _src(0), _arc(0) {} + sgb_out_edge_iterator(Vertex* s, Arc* d) : _src(s), _arc(d) {} + boost::sgb_edge operator*() { return boost::sgb_edge(_arc, _src); } + self& operator++() { _arc = _arc->next; return *this; } + friend bool operator==(const self& x, const self& y) { + return x._arc == y._arc; } + protected: + Vertex* _src; + Arc* _arc; + }; + + class sgb_adj_iterator + : public boost::forward_iterator_helper< + sgb_adj_iterator, Vertex*, std::ptrdiff_t, Vertex**,Vertex*> + { + typedef sgb_adj_iterator self; + public: + sgb_adj_iterator() : _arc(0) {} + sgb_adj_iterator(Arc* d) : _arc(d) {} + Vertex* operator*() { return _arc->tip; } + self& operator++() { _arc = _arc->next; return *this; } + friend bool operator==(const self& x, const self& y) { + return x._arc == y._arc; } + protected: + Arc* _arc; + }; + + // The reason we have this instead of just using Vertex* is that we + // want to use Vertex* as the vertex_descriptor instead of just + // Vertex, which avoids problems with boost passing vertex descriptors + // by value and how that interacts with the sgb_vertex_id_map. + class sgb_vertex_iterator + : public boost::forward_iterator_helper< + sgb_vertex_iterator, Vertex*, std::ptrdiff_t, Vertex**, Vertex*> + { + typedef sgb_vertex_iterator self; + public: + sgb_vertex_iterator() : _v(0) { } + sgb_vertex_iterator(Vertex* v) : _v(v) { } + Vertex* operator*() { return _v; } + self& operator++() { ++_v; return *this; } + friend bool operator==(const self& x, const self& y) { + return x._v == y._v; } + protected: + Vertex* _v; + }; + +namespace boost { + + inline std::pair + vertices(sgb_const_graph_ptr g) + { + return std::make_pair(sgb_vertex_iterator(g->vertices), + sgb_vertex_iterator(g->vertices + g->n)); + } + + inline std::pair + out_edges(Vertex* u, sgb_const_graph_ptr) + { + return std::make_pair( sgb_out_edge_iterator(u, u->arcs), + sgb_out_edge_iterator(u, 0) ); + } + + inline boost::graph_traits::degree_size_type + out_degree(Vertex* u, sgb_const_graph_ptr g) + { + boost::graph_traits::out_edge_iterator i, i_end; + boost::tie(i, i_end) = out_edges(u, g); + return std::distance(i, i_end); + } + + // in_edges? + + inline std::pair + adjacent_vertices(Vertex* u, sgb_const_graph_ptr) + { + return std::make_pair( sgb_adj_iterator(u->arcs), + sgb_adj_iterator(0) ); + } + + inline long num_vertices(sgb_const_graph_ptr g) { return g->n; } + inline long num_edges(sgb_const_graph_ptr g) { return g->m; } + + inline Vertex* vertex(long v, sgb_const_graph_ptr g) + { return g->vertices + v; } + + // Various Property Maps + + // Vertex ID + class sgb_vertex_id_map + : public boost::put_get_helper + { + public: + typedef boost::readable_property_map_tag category; + typedef long value_type; + typedef long reference; + typedef Vertex* key_type; + sgb_vertex_id_map() : _g(0) { } + sgb_vertex_id_map(sgb_graph_ptr g) : _g(g) { } + long operator[](Vertex* v) const { return v - _g->vertices; } + protected: + sgb_graph_ptr _g; + }; + inline sgb_vertex_id_map get(vertex_index_t, sgb_graph_ptr g) { + return sgb_vertex_id_map(g); + } + + // Vertex Name + class sgb_vertex_name_map + : public boost::put_get_helper + { + public: + typedef boost::readable_property_map_tag category; + typedef char* value_type; + typedef char* reference; + typedef Vertex* key_type; + char* operator[](Vertex* v) const { return v->name; } + }; + inline sgb_vertex_name_map get(vertex_name_t, sgb_graph_ptr) { + return sgb_vertex_name_map(); + } + + // Vertex Property Tags +#define SGB_PROPERTY_TAG(KIND,TAG) \ + template struct TAG##_property { \ + typedef KIND##_property_tag kind; \ + typedef T type; \ + }; + SGB_PROPERTY_TAG(vertex, u) + SGB_PROPERTY_TAG(vertex, v) + SGB_PROPERTY_TAG(vertex, w) + SGB_PROPERTY_TAG(vertex, x) + SGB_PROPERTY_TAG(vertex, y) + SGB_PROPERTY_TAG(vertex, z) + + // Edge Property Tags + SGB_PROPERTY_TAG(edge, a) + SGB_PROPERTY_TAG(edge, b) + + // Various Utility Maps + + // helpers + inline Vertex*& get_util(util& u, Vertex*) { return u.V; } + inline Arc*& get_util(util& u, Arc*) { return u.A; } + inline sgb_graph_ptr& get_util(util& u, sgb_graph_ptr) { return u.G; } + inline char*& get_util(util& u, char*) { return u.S; } + inline long& get_util(util& u, long) { return u.I; } + +#define SGB_GET_UTIL_FIELD(KIND,X) \ + template \ + inline T& get_util_field(KIND* k, X##_property) { \ + return get_util(k->X, T()); } + + SGB_GET_UTIL_FIELD(Vertex, u) + SGB_GET_UTIL_FIELD(Vertex, v) + SGB_GET_UTIL_FIELD(Vertex, w) + SGB_GET_UTIL_FIELD(Vertex, x) + SGB_GET_UTIL_FIELD(Vertex, y) + SGB_GET_UTIL_FIELD(Vertex, z) + + SGB_GET_UTIL_FIELD(Arc, a) + SGB_GET_UTIL_FIELD(Arc, b) + + // Vertex Utility Map + template + class sgb_vertex_util_map + : public boost::put_get_helper > + { + public: + typedef boost::lvalue_property_map_tag category; + typedef typename Tag::type value_type; + typedef Vertex* key_type; + typedef Ref reference; + reference operator[](Vertex* v) const { + return get_util_field(v, Tag()); + } + }; + + // Edge Utility Map + template + class sgb_edge_util_map + : public boost::put_get_helper > + { + public: + typedef boost::lvalue_property_map_tag category; + typedef typename Tag::type value_type; + typedef Vertex* key_type; + typedef Ref reference; + reference operator[](const sgb_edge& e) const { + return get_util_field(e._arc, Tag()); + } + }; + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + template + inline sgb_vertex_util_map + get_property_map(Tag, const sgb_graph_ptr& g, vertex_property_tag) { + return sgb_vertex_util_map(); + } + template + inline sgb_vertex_util_map + get_property_map(Tag, sgb_graph_ptr& g, vertex_property_tag) { + return sgb_vertex_util_map(); + } + + template + inline sgb_edge_util_map + get_property_map(Tag, const sgb_graph_ptr& g, edge_property_tag) { + return sgb_edge_util_map(); + } + template + inline sgb_edge_util_map + get_property_map(Tag, sgb_graph_ptr& g, edge_property_tag) { + return sgb_edge_util_map(); + } + +#endif // ! BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + // Edge Length Access + template + class sgb_edge_length_map + : public boost::put_get_helper > + { + public: + typedef boost::lvalue_property_map_tag category; + typedef long value_type; + typedef sgb_edge key_type; + typedef Ref reference; + reference operator[](const sgb_edge& e) const { + return e._arc->len; + } + }; + + inline sgb_edge_length_map + get(edge_length_t, const sgb_graph_ptr&) { + return sgb_edge_length_map(); + } + inline sgb_edge_length_map + get(edge_length_t, const sgb_const_graph_ptr&) { + return sgb_edge_length_map(); + } + inline sgb_edge_length_map + get(edge_length_t, sgb_graph_ptr&) { + return sgb_edge_length_map(); + } + inline long + get(edge_length_t, const sgb_graph_ptr&, const sgb_edge& key) { + return key._arc->len; + } + inline long + get(edge_length_t, const sgb_const_graph_ptr&, const sgb_edge& key) { + return key._arc->len; + } + inline void + put(edge_length_t, sgb_graph_ptr&, const sgb_edge& key, long value) + { + key._arc->len = value; + } + + // Property Map Traits Classes + template <> + struct property_map { + typedef sgb_edge_length_map type; + typedef sgb_edge_length_map const_type; + }; + template <> + struct property_map { + typedef sgb_vertex_id_map type; + typedef sgb_vertex_id_map const_type; + }; + template <> + struct property_map { + typedef sgb_vertex_name_map type; + typedef sgb_vertex_name_map const_type; + }; + + template <> + struct property_map { + typedef sgb_edge_length_map const_type; + }; + template <> + struct property_map { + typedef sgb_vertex_id_map const_type; + }; + template <> + struct property_map { + typedef sgb_vertex_name_map const_type; + }; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + + namespace detail { + template + struct sgb_choose_property_map { }; + template + struct sgb_choose_property_map { + typedef typename PropertyTag::type value_type; + typedef sgb_vertex_util_map type; + typedef sgb_vertex_util_map const_type; + }; + template + struct sgb_choose_property_map { + typedef typename PropertyTag::type value_type; + typedef sgb_edge_util_map type; + typedef sgb_edge_util_map const_type; + }; + } // namespace detail + template + struct property_map { + typedef typename property_kind::type Kind; + typedef detail::sgb_choose_property_map Choice; + typedef typename Choice::type type; + typedef typename Choice::const_type const_type; + }; + template + struct property_map { + typedef typename property_kind::type Kind; + typedef detail::sgb_choose_property_map Choice; + typedef typename Choice::const_type const_type; + }; + +#define SGB_UTIL_ACCESSOR(KIND,X) \ + template \ + inline sgb_##KIND##_util_map< X##_property, T&> \ + get(X##_property, sgb_graph_ptr&) { \ + return sgb_##KIND##_util_map< X##_property, T&>(); \ + } \ + template \ + inline sgb_##KIND##_util_map< X##_property, const T&> \ + get(X##_property, const sgb_graph_ptr&) { \ + return sgb_##KIND##_util_map< X##_property, const T&>(); \ + } \ + template \ + inline sgb_##KIND##_util_map< X##_property, const T&> \ + get(X##_property, const sgb_const_graph_ptr&) { \ + return sgb_##KIND##_util_map< X##_property, const T&>(); \ + } \ + template \ + inline typename \ + sgb_##KIND##_util_map< X##_property, const T&>::value_type \ + get(X##_property, const sgb_graph_ptr&, const Key& key) { \ + return sgb_##KIND##_util_map< X##_property, const T&>()[key]; \ + } \ + template \ + inline typename \ + sgb_##KIND##_util_map< X##_property, const T&>::value_type \ + get(X##_property, const sgb_const_graph_ptr&, const Key& key) { \ + return sgb_##KIND##_util_map< X##_property, const T&>()[key]; \ + } \ + template \ + inline void \ + put(X##_property, sgb_graph_ptr&, const Key& key, const Value& value) { \ + sgb_##KIND##_util_map< X##_property, T&>()[key] = value; \ + } + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#define SGB_UTIL_ACCESSOR_TYPE(KIND,TAG,TYPE) \ + inline sgb_##KIND##_util_map< TAG, TYPE& > \ + get(TAG, sgb_graph_ptr&) { \ + return sgb_##KIND##_util_map< TAG, TYPE& >(); \ + } \ + inline sgb_##KIND##_util_map< TAG, const TYPE& > \ + get(TAG, const sgb_graph_ptr&) { \ + return sgb_##KIND##_util_map< TAG, const TYPE& >(); \ + } \ + inline sgb_##KIND##_util_map< TAG, const TYPE& > \ + get(TAG, const sgb_const_graph_ptr&) { \ + return sgb_##KIND##_util_map< TAG, const TYPE& >(); \ + } \ + template \ + inline typename sgb_##KIND##_util_map< TAG, const TYPE& >::value_type \ + get(TAG, const sgb_graph_ptr&, const Key& key) { \ + return sgb_##KIND##_util_map< TAG, const TYPE& >()[key]; \ + } \ + template \ + inline typename sgb_##KIND##_util_map< TAG, const TYPE& >::value_type \ + get(TAG, const sgb_const_graph_ptr&, const Key& key) { \ + return sgb_##KIND##_util_map< TAG, const TYPE& >()[key]; \ + } \ + template \ + inline void \ + put(TAG, sgb_graph_ptr&, const Key& key, const Value& value) { \ + sgb_##KIND##_util_map< TAG, TYPE& >()[key] = value; \ + } \ + template <> struct property_map > { \ + typedef sgb_##KIND##_util_map< TAG, TYPE&> type; \ + typedef sgb_##KIND##_util_map< TAG, const TYPE&> const_type; \ + } + +#define SGB_UTIL_ACCESSOR(KIND,TAG) \ + SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, Vertex*); \ + SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, Arc*); \ + SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, sgb_graph_ptr); \ + SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, long); \ + SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, char*); + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + SGB_UTIL_ACCESSOR(vertex, u) + SGB_UTIL_ACCESSOR(vertex, v) + SGB_UTIL_ACCESSOR(vertex, w) + SGB_UTIL_ACCESSOR(vertex, x) + SGB_UTIL_ACCESSOR(vertex, y) + SGB_UTIL_ACCESSOR(vertex, z) + + SGB_UTIL_ACCESSOR(edge, a) + SGB_UTIL_ACCESSOR(edge, b) + +} // namespace boost + +#endif // BOOST_GRAPH_SGB_GRAPH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/strong_components.hpp b/deal.II/contrib/boost/include/boost/graph/strong_components.hpp new file mode 100644 index 0000000000..0ed0b4a19b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/strong_components.hpp @@ -0,0 +1,334 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_STRONG_COMPONENTS_HPP +#define BOOST_GRAPH_STRONG_COMPONENTS_HPP + +#include +#include +#include +#include +#include + +namespace boost { + + //========================================================================== + // This is Tarjan's algorithm for strongly connected components + // from his paper "Depth first search and linear graph algorithms". + // It calculates the components in a single application of DFS. + // We implement the algorithm as a dfs-visitor. + + namespace detail { + + template + class tarjan_scc_visitor : public dfs_visitor<> + { + typedef typename property_traits::value_type comp_type; + typedef typename property_traits::value_type time_type; + public: + tarjan_scc_visitor(ComponentMap comp_map, RootMap r, DiscoverTime d, + comp_type& c_, Stack& s_) + : c(c_), comp(comp_map), root(r), discover_time(d), + dfs_time(time_type()), s(s_) { } + + template + void discover_vertex(typename graph_traits::vertex_descriptor v, + const Graph&) { + put(root, v, v); + put(comp, v, (std::numeric_limits::max)()); + put(discover_time, v, dfs_time++); + s.push(v); + } + template + void finish_vertex(typename graph_traits::vertex_descriptor v, + const Graph& g) { + typename graph_traits::vertex_descriptor w; + typename graph_traits::out_edge_iterator ei, ei_end; + for (tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) { + w = target(*ei, g); + if (get(comp, w) == (std::numeric_limits::max)()) + put(root, v, this->min_discover_time(get(root,v), get(root,w))); + } + if (get(root, v) == v) { + do { + w = s.top(); s.pop(); + put(comp, w, c); + } while (w != v); + ++c; + } + } + private: + template + Vertex min_discover_time(Vertex u, Vertex v) { + return get(discover_time, u) < get(discover_time,v) ? u : v; + } + + comp_type& c; + ComponentMap comp; + RootMap root; + DiscoverTime discover_time; + time_type dfs_time; + Stack& s; + }; + + template + typename property_traits::value_type + strong_components_impl + (const Graph& g, // Input + ComponentMap comp, // Output + // Internal record keeping + RootMap root, + DiscoverTime discover_time, + const bgl_named_params& params) + { + typedef typename graph_traits::vertex_descriptor Vertex; + function_requires< ReadWritePropertyMapConcept >(); + function_requires< ReadWritePropertyMapConcept >(); + typedef typename property_traits::value_type RootV; + function_requires< ConvertibleConcept >(); + function_requires< ReadWritePropertyMapConcept >(); + + typename property_traits::value_type total = 0; + + std::stack s; + detail::tarjan_scc_visitor > + vis(comp, root, discover_time, total, s); + depth_first_search(g, params.visitor(vis)); + return total; + } + + //------------------------------------------------------------------------- + // The dispatch functions handle the defaults for the rank and discover + // time property maps. + // dispatch with class specialization to avoid VC++ bug + + template + struct strong_comp_dispatch2 { + template + inline static typename property_traits::value_type + apply(const Graph& g, + ComponentMap comp, + RootMap r_map, + const bgl_named_params& params, + DiscoverTimeMap time_map) + { + return strong_components_impl(g, comp, r_map, time_map, params); + } + }; + + + template <> + struct strong_comp_dispatch2 { + template + inline static typename property_traits::value_type + apply(const Graph& g, + ComponentMap comp, + RootMap r_map, + const bgl_named_params& params, + detail::error_property_not_found) + { + typedef typename graph_traits::vertices_size_type size_type; + size_type n = num_vertices(g) > 0 ? num_vertices(g) : 1; + std::vector time_vec(n); + return strong_components_impl + (g, comp, r_map, + make_iterator_property_map(time_vec.begin(), choose_const_pmap + (get_param(params, vertex_index), + g, vertex_index), time_vec[0]), + params); + } + }; + + template + inline typename property_traits::value_type + scc_helper2(const Graph& g, + ComponentMap comp, + RootMap r_map, + const bgl_named_params& params, + DiscoverTimeMap time_map) + { + return strong_comp_dispatch2::apply(g, comp, r_map, params, time_map); + } + + template + struct strong_comp_dispatch1 { + + template + inline static typename property_traits::value_type + apply(const Graph& g, + ComponentMap comp, + const bgl_named_params& params, + RootMap r_map) + { + return scc_helper2(g, comp, r_map, params, get_param(params, vertex_discover_time)); + } + }; + template <> + struct strong_comp_dispatch1 { + + template + inline static typename property_traits::value_type + apply(const Graph& g, + ComponentMap comp, + const bgl_named_params& params, + detail::error_property_not_found) + { + typedef typename graph_traits::vertex_descriptor Vertex; + typename std::vector::size_type + n = num_vertices(g) > 0 ? num_vertices(g) : 1; + std::vector root_vec(n); + return scc_helper2 + (g, comp, + make_iterator_property_map(root_vec.begin(), choose_const_pmap + (get_param(params, vertex_index), + g, vertex_index), root_vec[0]), + params, + get_param(params, vertex_discover_time)); + } + }; + + template + inline typename property_traits::value_type + scc_helper1(const Graph& g, + ComponentMap comp, + const bgl_named_params& params, + RootMap r_map) + { + return detail::strong_comp_dispatch1::apply(g, comp, params, + r_map); + } + + } // namespace detail + + template + inline typename property_traits::value_type + strong_components(const Graph& g, ComponentMap comp, + const bgl_named_params& params) + { + typedef typename graph_traits::directed_category DirCat; + BOOST_STATIC_ASSERT((is_convertible::value == true)); + return detail::scc_helper1(g, comp, params, + get_param(params, vertex_root_t())); + } + + template + inline typename property_traits::value_type + strong_components(const Graph& g, ComponentMap comp) + { + typedef typename graph_traits::directed_category DirCat; + BOOST_STATIC_ASSERT((is_convertible::value == true)); + bgl_named_params params(0); + return strong_components(g, comp, params); + } + + template + void build_component_lists + (const Graph& g, + typename graph_traits::vertices_size_type num_scc, + ComponentMap component_number, + ComponentLists& components) + { + components.resize(num_scc); + typename graph_traits::vertex_iterator vi, vi_end; + for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) + components[component_number[*vi]].push_back(*vi); + } + + +} // namespace boost + +#include +#include +#include +#include +#include // for components_recorder + +namespace boost { + + //========================================================================== + // This is the version of strongly connected components from + // "Intro. to Algorithms" by Cormen, Leiserson, Rivest, which was + // adapted from "Data Structure and Algorithms" by Aho, Hopcroft, + // and Ullman, who credit the algorithm to S.R. Kosaraju and M. Sharir. + // The algorithm is based on computing DFS forests the graph + // and its transpose. + + // This algorithm is slower than Tarjan's by a constant factor, uses + // more memory, and puts more requirements on the graph type. + + template + typename property_traits::value_type + kosaraju_strong_components(Graph& G, ComponentsMap c, + FinishTime finish_time, ColorMap color) + { + function_requires< MutableGraphConcept >(); + // ... + + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + typename property_traits::value_type time = 0; + depth_first_search + (G, make_dfs_visitor(stamp_times(finish_time, time, on_finish_vertex())), + color); + + Graph G_T(num_vertices(G)); + transpose_graph(G, G_T); + + typedef typename property_traits::value_type count_type; + + count_type c_count(0); + detail::components_recorder + vis(c, c_count); + + // initialize G_T + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(G_T); ui != ui_end; ++ui) + put(color, *ui, Color::white()); + + typedef typename property_traits::value_type D; + typedef indirect_cmp< FinishTime, std::less > Compare; + + Compare fl(finish_time); + std::priority_queue, Compare > Q(fl); + + typename graph_traits::vertex_iterator i, j, iend, jend; + tie(i, iend) = vertices(G_T); + tie(j, jend) = vertices(G); + for ( ; i != iend; ++i, ++j) { + put(finish_time, *i, get(finish_time, *j)); + Q.push(*i); + } + + while ( !Q.empty() ) { + Vertex u = Q.top(); + Q.pop(); + if (get(color, u) == Color::white()) { + depth_first_visit(G_T, u, vis, color); + ++c_count; + } + } + return c_count; + } + +} // namespace boost + +#endif // BOOST_GRAPH_STRONG_COMPONENTS_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/subgraph.hpp b/deal.II/contrib/boost/include/boost/graph/subgraph.hpp new file mode 100644 index 0000000000..91d2e05fcf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/subgraph.hpp @@ -0,0 +1,872 @@ +//======================================================================= +// Copyright 2001 University of Notre Dame. +// Authors: Jeremy G. Siek and Lie-Quan Lee +// +// 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_SUBGRAPH_HPP +#define BOOST_SUBGRAPH_HPP + +// UNDER CONSTRUCTION + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace boost { + + struct subgraph_tag { }; + + // Invariants of an induced subgraph: + // - If vertex u is in subgraph g, then u must be in g.parent(). + // - If edge e is in subgraph g, then e must be in g.parent(). + // - If edge e=(u,v) is in the root graph, then edge e + // is also in any subgraph that contains both vertex u and v. + + // The Graph template parameter must have a vertex_index + // and edge_index internal property. It is assumed that + // the vertex indices are assigned automatically by the + // graph during a call to add_vertex(). It is not + // assumed that the edge vertices are assigned automatically, + // they are explicitly assigned here. + + template + class subgraph { + typedef graph_traits Traits; + typedef std::list*> ChildrenList; + public: + // Graph requirements + typedef typename Traits::vertex_descriptor vertex_descriptor; + typedef typename Traits::edge_descriptor edge_descriptor; + typedef typename Traits::directed_category directed_category; + typedef typename Traits::edge_parallel_category edge_parallel_category; + typedef typename Traits::traversal_category traversal_category; + + static vertex_descriptor null_vertex() + { + return Traits::null_vertex(); + } + + + // IncidenceGraph requirements + typedef typename Traits::out_edge_iterator out_edge_iterator; + typedef typename Traits::degree_size_type degree_size_type; + + // AdjacencyGraph requirements + typedef typename Traits::adjacency_iterator adjacency_iterator; + + // VertexListGraph requirements + typedef typename Traits::vertex_iterator vertex_iterator; + typedef typename Traits::vertices_size_type vertices_size_type; + + // EdgeListGraph requirements + typedef typename Traits::edge_iterator edge_iterator; + typedef typename Traits::edges_size_type edges_size_type; + + typedef typename Traits::in_edge_iterator in_edge_iterator; + + typedef typename Graph::edge_property_type edge_property_type; + typedef typename Graph::vertex_property_type vertex_property_type; + typedef subgraph_tag graph_tag; + typedef Graph graph_type; + typedef typename Graph::graph_property_type graph_property_type; + + // Constructors + + // Create the main graph, the root of the subgraph tree + subgraph() + : m_parent(0), m_edge_counter(0) + { } + subgraph(const graph_property_type& p) + : m_graph(p), m_parent(0), m_edge_counter(0) + { } + subgraph(vertices_size_type n, + const graph_property_type& p = graph_property_type()) + : m_graph(n, p), m_parent(0), m_edge_counter(0), m_global_vertex(n) + { + typename Graph::vertex_iterator v, v_end; + vertices_size_type i = 0; + for (tie(v, v_end) = vertices(m_graph); v != v_end; ++v) + m_global_vertex[i++] = *v; + } + + // copy constructor + subgraph(const subgraph& x) + : m_graph(x.m_graph), m_parent(x.m_parent), + m_edge_counter(x.m_edge_counter), + m_global_vertex(x.m_global_vertex), + m_global_edge(x.m_global_edge) + { + // Do a deep copy + for (typename ChildrenList::const_iterator i = x.m_children.begin(); + i != x.m_children.end(); ++i) + m_children.push_back(new subgraph( **i )); + } + + + ~subgraph() { + for (typename ChildrenList::iterator i = m_children.begin(); + i != m_children.end(); ++i) + delete *i; + } + + + // Create a subgraph + subgraph& create_subgraph() { + m_children.push_back(new subgraph()); + m_children.back()->m_parent = this; + return *m_children.back(); + } + + // Create a subgraph with the specified vertex set. + template + subgraph& create_subgraph(VertexIterator first, + VertexIterator last) + { + m_children.push_back(new subgraph()); + m_children.back()->m_parent = this; + for (; first != last; ++first) + add_vertex(*first, *m_children.back()); + return *m_children.back(); + } + + // local <-> global descriptor conversion functions + vertex_descriptor local_to_global(vertex_descriptor u_local) const + { + return m_global_vertex[u_local]; + } + vertex_descriptor global_to_local(vertex_descriptor u_global) const + { + vertex_descriptor u_local; bool in_subgraph; + tie(u_local, in_subgraph) = this->find_vertex(u_global); + assert(in_subgraph == true); + return u_local; + } + edge_descriptor local_to_global(edge_descriptor e_local) const + { + return m_global_edge[get(get(edge_index, m_graph), e_local)]; + } + edge_descriptor global_to_local(edge_descriptor e_global) const + { + return + (*m_local_edge.find(get(get(edge_index, root().m_graph), e_global))).second; + } + + // Is vertex u (of the root graph) contained in this subgraph? + // If so, return the matching local vertex. + std::pair + find_vertex(vertex_descriptor u_global) const + { + typename std::map::const_iterator + i = m_local_vertex.find(u_global); + bool valid = i != m_local_vertex.end(); + return std::make_pair((valid ? (*i).second : null_vertex()), valid); + } + + // Return the parent graph. + subgraph& parent() { return *m_parent; } + const subgraph& parent() const { return *m_parent; } + + bool is_root() const { return m_parent == 0; } + + // Return the root graph of the subgraph tree. + subgraph& root() { + if (this->is_root()) + return *this; + else + return m_parent->root(); + } + const subgraph& root() const { + if (this->is_root()) + return *this; + else + return m_parent->root(); + } + + // Return the children subgraphs of this graph/subgraph. + // Use a list of pointers because the VC++ std::list doesn't like + // storing incomplete type. + typedef indirect_iterator< + typename ChildrenList::const_iterator + , subgraph + , std::bidirectional_iterator_tag + > + children_iterator; + + typedef indirect_iterator< + typename ChildrenList::const_iterator + , subgraph const + , std::bidirectional_iterator_tag + > + const_children_iterator; + + std::pair + children() const + { + return std::make_pair(const_children_iterator(m_children.begin()), + const_children_iterator(m_children.end())); + } + + std::pair + children() + { + return std::make_pair(children_iterator(m_children.begin()), + children_iterator(m_children.end())); + } + + std::size_t num_children() const { return m_children.size(); } + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + // Bundled properties support + template + typename graph::detail::bundled_result::type& + operator[](Descriptor x) + { + if (m_parent == 0) return m_graph[x]; + else return root().m_graph[local_to_global(x)]; + } + + template + typename graph::detail::bundled_result::type const& + operator[](Descriptor x) const + { + if (m_parent == 0) return m_graph[x]; + else return root().m_graph[local_to_global(x)]; + } +#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES + + // private: + typedef typename property_map::type EdgeIndexMap; + typedef typename property_traits::value_type edge_index_type; + BOOST_STATIC_ASSERT((!is_same::value)); + + Graph m_graph; + subgraph* m_parent; + edge_index_type m_edge_counter; // for generating unique edge indices + ChildrenList m_children; + std::vector m_global_vertex; // local -> global + std::map m_local_vertex; // global -> local + std::vector m_global_edge; // local -> global + std::map m_local_edge; // global -> local + + edge_descriptor + local_add_edge(vertex_descriptor u_local, vertex_descriptor v_local, + edge_descriptor e_global) + { + edge_descriptor e_local; + bool inserted; + tie(e_local, inserted) = add_edge(u_local, v_local, m_graph); + put(edge_index, m_graph, e_local, m_edge_counter++); + m_global_edge.push_back(e_global); + m_local_edge[get(get(edge_index, this->root()), e_global)] = e_local; + return e_local; + } + + }; + +#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES + template + struct vertex_bundle_type > : vertex_bundle_type { }; + + template + struct edge_bundle_type > : edge_bundle_type { }; +#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES + + //=========================================================================== + // Functions special to the Subgraph Class + + template + typename subgraph::vertex_descriptor + add_vertex(typename subgraph::vertex_descriptor u_global, + subgraph& g) + { + assert(!g.is_root()); + typename subgraph::vertex_descriptor u_local, v_global, uu_global; + typename subgraph::edge_descriptor e_global; + + u_local = add_vertex(g.m_graph); + g.m_global_vertex.push_back(u_global); + g.m_local_vertex[u_global] = u_local; + + subgraph& r = g.root(); + + // remember edge global and local maps + { + typename subgraph::out_edge_iterator ei, ei_end; + for (tie(ei, ei_end) = out_edges(u_global, r); + ei != ei_end; ++ei) { + e_global = *ei; + v_global = target(e_global, r); + if (g.find_vertex(v_global).second == true) + g.local_add_edge(u_local, g.global_to_local(v_global), e_global); + } + } + if (is_directed(g)) { // not necessary for undirected graph + typename subgraph::vertex_iterator vi, vi_end; + typename subgraph::out_edge_iterator ei, ei_end; + for (tie(vi, vi_end) = vertices(r); vi != vi_end; ++vi) { + v_global = *vi; + if (g.find_vertex(v_global).second) + for (tie(ei, ei_end) = out_edges(*vi, r); ei != ei_end; ++ei) { + e_global = *ei; + uu_global = target(e_global, r); + if (uu_global == u_global && g.find_vertex(v_global).second) + g.local_add_edge(g.global_to_local(v_global), u_local, e_global); + } + } + } + + return u_local; + } + + //=========================================================================== + // Functions required by the IncidenceGraph concept + + template + std::pair::out_edge_iterator, + typename graph_traits::out_edge_iterator> + out_edges(typename graph_traits::vertex_descriptor u_local, + const subgraph& g) + { return out_edges(u_local, g.m_graph); } + + template + typename graph_traits::degree_size_type + out_degree(typename graph_traits::vertex_descriptor u_local, + const subgraph& g) + { return out_degree(u_local, g.m_graph); } + + template + typename graph_traits::vertex_descriptor + source(typename graph_traits::edge_descriptor e_local, + const subgraph& g) + { return source(e_local, g.m_graph); } + + template + typename graph_traits::vertex_descriptor + target(typename graph_traits::edge_descriptor e_local, + const subgraph& g) + { return target(e_local, g.m_graph); } + + //=========================================================================== + // Functions required by the BidirectionalGraph concept + + template + std::pair::in_edge_iterator, + typename graph_traits::in_edge_iterator> + in_edges(typename graph_traits::vertex_descriptor u_local, + const subgraph& g) + { return in_edges(u_local, g.m_graph); } + + template + typename graph_traits::degree_size_type + in_degree(typename graph_traits::vertex_descriptor u_local, + const subgraph& g) + { return in_degree(u_local, g.m_graph); } + + template + typename graph_traits::degree_size_type + degree(typename graph_traits::vertex_descriptor u_local, + const subgraph& g) + { return degree(u_local, g.m_graph); } + + //=========================================================================== + // Functions required by the AdjacencyGraph concept + + template + std::pair::adjacency_iterator, + typename subgraph::adjacency_iterator> + adjacent_vertices(typename subgraph::vertex_descriptor u_local, + const subgraph& g) + { return adjacent_vertices(u_local, g.m_graph); } + + //=========================================================================== + // Functions required by the VertexListGraph concept + + template + std::pair::vertex_iterator, + typename subgraph::vertex_iterator> + vertices(const subgraph& g) + { return vertices(g.m_graph); } + + template + typename subgraph::vertices_size_type + num_vertices(const subgraph& g) + { return num_vertices(g.m_graph); } + + //=========================================================================== + // Functions required by the EdgeListGraph concept + + template + std::pair::edge_iterator, + typename subgraph::edge_iterator> + edges(const subgraph& g) + { return edges(g.m_graph); } + + template + typename subgraph::edges_size_type + num_edges(const subgraph& g) + { return num_edges(g.m_graph); } + + //=========================================================================== + // Functions required by the AdjacencyMatrix concept + + template + std::pair::edge_descriptor, bool> + edge(typename subgraph::vertex_descriptor u_local, + typename subgraph::vertex_descriptor v_local, + const subgraph& g) + { + return edge(u_local, v_local, g.m_graph); + } + + //=========================================================================== + // Functions required by the MutableGraph concept + + namespace detail { + + template + void add_edge_recur_down + (Vertex u_global, Vertex v_global, Edge e_global, subgraph& g); + + template + void children_add_edge(Vertex u_global, Vertex v_global, Edge e_global, + Children& c, subgraph* orig) + { + for (typename Children::iterator i = c.begin(); i != c.end(); ++i) + if ((*i)->find_vertex(u_global).second + && (*i)->find_vertex(v_global).second) + add_edge_recur_down(u_global, v_global, e_global, **i, orig); + } + + template + void add_edge_recur_down + (Vertex u_global, Vertex v_global, Edge e_global, subgraph& g, + subgraph* orig) + { + if (&g != orig ) { + // add local edge only if u_global and v_global are in subgraph g + Vertex u_local, v_local; + bool u_in_subgraph, v_in_subgraph; + tie(u_local, u_in_subgraph) = g.find_vertex(u_global); + tie(v_local, v_in_subgraph) = g.find_vertex(v_global); + if (u_in_subgraph && v_in_subgraph) + g.local_add_edge(u_local, v_local, e_global); + } + children_add_edge(u_global, v_global, e_global, g.m_children, orig); + } + + template + std::pair::edge_descriptor, bool> + add_edge_recur_up(Vertex u_global, Vertex v_global, + const typename Graph::edge_property_type& ep, + subgraph& g, subgraph* orig) + { + if (g.is_root()) { + typename subgraph::edge_descriptor e_global; + bool inserted; + tie(e_global, inserted) = add_edge(u_global, v_global, ep, g.m_graph); + put(edge_index, g.m_graph, e_global, g.m_edge_counter++); + g.m_global_edge.push_back(e_global); + children_add_edge(u_global, v_global, e_global, g.m_children, orig); + return std::make_pair(e_global, inserted); + } else + return add_edge_recur_up(u_global, v_global, ep, *g.m_parent, orig); + } + + } // namespace detail + + // Add an edge to the subgraph g, specified by the local vertex + // descriptors u and v. In addition, the edge will be added to any + // other subgraphs which contain vertex descriptors u and v. + + template + std::pair::edge_descriptor, bool> + add_edge(typename subgraph::vertex_descriptor u_local, + typename subgraph::vertex_descriptor v_local, + const typename G::edge_property_type& ep, + subgraph& g) + { + if (g.is_root()) // u_local and v_local are really global + return detail::add_edge_recur_up(u_local, v_local, ep, g, &g); + else { + typename subgraph::edge_descriptor e_local, e_global; + bool inserted; + tie(e_global, inserted) = detail::add_edge_recur_up + (g.local_to_global(u_local), g.local_to_global(v_local), ep, g, &g); + e_local = g.local_add_edge(u_local, v_local, e_global); + return std::make_pair(e_local, inserted); + } + } + + template + std::pair::edge_descriptor, bool> + add_edge(typename subgraph::vertex_descriptor u, + typename subgraph::vertex_descriptor v, + subgraph& g) + { + typename G::edge_property_type ep; + return add_edge(u, v, ep, g); + } + + namespace detail { + + //------------------------------------------------------------------------- + // implementation of remove_edge(u,v,g) + + template + void remove_edge_recur_down(Vertex u_global, Vertex v_global, + subgraph& g); + + template + void children_remove_edge(Vertex u_global, Vertex v_global, + Children& c) + { + for (typename Children::iterator i = c.begin(); i != c.end(); ++i) + if ((*i)->find_vertex(u_global).second + && (*i)->find_vertex(v_global).second) + remove_edge_recur_down(u_global, v_global, **i); + } + + template + void remove_edge_recur_down(Vertex u_global, Vertex v_global, + subgraph& g) + { + Vertex u_local, v_local; + u_local = g.m_local_vertex[u_global]; + v_local = g.m_local_vertex[v_global]; + remove_edge(u_local, v_local, g.m_graph); + children_remove_edge(u_global, v_global, g.m_children); + } + + template + void remove_edge_recur_up(Vertex u_global, Vertex v_global, + subgraph& g) + { + if (g.is_root()) { + remove_edge(u_global, v_global, g.m_graph); + children_remove_edge(u_global, v_global, g.m_children); + } else + remove_edge_recur_up(u_global, v_global, *g.m_parent); + } + + //------------------------------------------------------------------------- + // implementation of remove_edge(e,g) + + template + void remove_edge_recur_down(Edge e_global, subgraph& g); + + template + void children_remove_edge(Edge e_global, Children& c) + { + for (typename Children::iterator i = c.begin(); i != c.end(); ++i) + if ((*i)->find_vertex(source(e_global, **i)).second + && (*i)->find_vertex(target(e_global, **i)).second) + remove_edge_recur_down(source(e_global, **i), + target(e_global, **i), **i); + } + + template + void remove_edge_recur_down(Edge e_global, subgraph& g) + { + remove_edge(g.global_to_local(e_global), g.m_graph); + children_remove_edge(e_global, g.m_children); + } + + template + void remove_edge_recur_up(Edge e_global, subgraph& g) + { + if (g.is_root()) { + remove_edge(e_global, g.m_graph); + children_remove_edge(e_global, g.m_children); + } else + remove_edge_recur_up(e_global, *g.m_parent); + } + + } // namespace detail + + template + void + remove_edge(typename subgraph::vertex_descriptor u_local, + typename subgraph::vertex_descriptor v_local, + subgraph& g) + { + if (g.is_root()) + detail::remove_edge_recur_up(u_local, v_local, g); + else + detail::remove_edge_recur_up(g.local_to_global(u_local), + g.local_to_global(v_local), g); + } + + template + void + remove_edge(typename subgraph::edge_descriptor e_local, + subgraph& g) + { + if (g.is_root()) + detail::remove_edge_recur_up(e_local, g); + else + detail::remove_edge_recur_up(g.local_to_global(e_local), g); + } + + template + void + remove_edge_if(Predicate p, subgraph& g) + { + // This is wrong... + remove_edge_if(p, g.m_graph); + } + + template + void + clear_vertex(typename subgraph::vertex_descriptor v_local, + subgraph& g) + { + // this is wrong... + clear_vertex(v_local, g.m_graph); + } + + namespace detail { + + template + typename subgraph::vertex_descriptor + add_vertex_recur_up(subgraph& g) + { + typename subgraph::vertex_descriptor u_local, u_global; + if (g.is_root()) { + u_global = add_vertex(g.m_graph); + g.m_global_vertex.push_back(u_global); + } else { + u_global = add_vertex_recur_up(*g.m_parent); + u_local = add_vertex(g.m_graph); + g.m_global_vertex.push_back(u_global); + g.m_local_vertex[u_global] = u_local; + } + return u_global; + } + + } // namespace detail + + template + typename subgraph::vertex_descriptor + add_vertex(subgraph& g) + { + typename subgraph::vertex_descriptor u_local, u_global; + if (g.is_root()) { + u_global = add_vertex(g.m_graph); + g.m_global_vertex.push_back(u_global); + u_local = u_global; + } else { + u_global = detail::add_vertex_recur_up(g.parent()); + u_local = add_vertex(g.m_graph); + g.m_global_vertex.push_back(u_global); + g.m_local_vertex[u_global] = u_local; + } + return u_local; + } + + template + void remove_vertex(typename subgraph::vertex_descriptor u, + subgraph& g) + { + // UNDER CONSTRUCTION + assert(false); + } + + + //=========================================================================== + // Functions required by the PropertyGraph concept + + template + class subgraph_global_property_map + : public put_get_helper< + typename property_traits::reference, + subgraph_global_property_map > + { + typedef property_traits Traits; + public: + typedef typename Traits::category category; + typedef typename Traits::value_type value_type; + typedef typename Traits::key_type key_type; + typedef typename Traits::reference reference; + + subgraph_global_property_map() { } + + subgraph_global_property_map(GraphPtr g) + : m_g(g) { } + + inline reference operator[](key_type e_local) const { + PropertyMap pmap = get(Tag(), m_g->root().m_graph); + if (m_g->m_parent == 0) + return pmap[e_local]; + else + return pmap[m_g->local_to_global(e_local)]; + } + GraphPtr m_g; + }; + + template + class subgraph_local_property_map + : public put_get_helper< + typename property_traits::reference, + subgraph_local_property_map > + { + typedef property_traits Traits; + public: + typedef typename Traits::category category; + typedef typename Traits::value_type value_type; + typedef typename Traits::key_type key_type; + typedef typename Traits::reference reference; + + subgraph_local_property_map() { } + + subgraph_local_property_map(GraphPtr g) + : m_g(g) { } + + inline reference operator[](key_type e_local) const { + PropertyMap pmap = get(Tag(), *m_g); + return pmap[e_local]; + } + GraphPtr m_g; + }; + + namespace detail { + + struct subgraph_any_pmap { + template + class bind_ { + typedef typename SubGraph::graph_type Graph; + typedef SubGraph* SubGraphPtr; + typedef const SubGraph* const_SubGraphPtr; + typedef typename property_map::type PMap; + typedef typename property_map::const_type const_PMap; + public: + typedef subgraph_global_property_map type; + typedef subgraph_global_property_map + const_type; + }; + }; + struct subgraph_id_pmap { + template + struct bind_ { + typedef typename SubGraph::graph_type Graph; + typedef SubGraph* SubGraphPtr; + typedef const SubGraph* const_SubGraphPtr; + typedef typename property_map::type PMap; + typedef typename property_map::const_type const_PMap; + public: + typedef subgraph_local_property_map type; + typedef subgraph_local_property_map + const_type; + }; + }; + template + struct subgraph_choose_pmap_helper { + typedef subgraph_any_pmap type; + }; + template <> + struct subgraph_choose_pmap_helper { + typedef subgraph_id_pmap type; + }; + template + struct subgraph_choose_pmap { + typedef typename subgraph_choose_pmap_helper::type Helper; + typedef typename Helper::template bind_ Bind; + typedef typename Bind::type type; + typedef typename Bind::const_type const_type; + }; + struct subgraph_property_generator { + template + struct bind_ { + typedef subgraph_choose_pmap Choice; + typedef typename Choice::type type; + typedef typename Choice::const_type const_type; + }; + }; + + } // namespace detail + + template <> + struct vertex_property_selector { + typedef detail::subgraph_property_generator type; + }; + + template <> + struct edge_property_selector { + typedef detail::subgraph_property_generator type; + }; + + template + typename property_map< subgraph, Property>::type + get(Property, subgraph& g) + { + typedef typename property_map< subgraph, Property>::type PMap; + return PMap(&g); + } + + template + typename property_map< subgraph, Property>::const_type + get(Property, const subgraph& g) + { + typedef typename property_map< subgraph, Property>::const_type PMap; + return PMap(&g); + } + + template + typename property_traits< + typename property_map< subgraph, Property>::const_type + >::value_type + get(Property, const subgraph& g, const Key& k) + { + typedef typename property_map< subgraph, Property>::const_type PMap; + PMap pmap(&g); + return pmap[k]; + } + + template + void + put(Property, subgraph& g, const Key& k, const Value& val) + { + typedef typename property_map< subgraph, Property>::type PMap; + PMap pmap(&g); + pmap[k] = val; + } + + template + inline + typename graph_property::type& + get_property(subgraph& g, Tag tag) { + return get_property(g.m_graph, tag); + } + + template + inline + const typename graph_property::type& + get_property(const subgraph& g, Tag tag) { + return get_property(g.m_graph, tag); + } + + //=========================================================================== + // Miscellaneous Functions + + template + typename subgraph::vertex_descriptor + vertex(typename subgraph::vertices_size_type n, const subgraph& g) + { + return vertex(n, g.m_graph); + } + +} // namespace boost + +#endif // BOOST_SUBGRAPH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/topological_sort.hpp b/deal.II/contrib/boost/include/boost/graph/topological_sort.hpp new file mode 100644 index 0000000000..2ed7e18e92 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/topological_sort.hpp @@ -0,0 +1,76 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_TOPOLOGICAL_SORT_HPP +#define BOOST_GRAPH_TOPOLOGICAL_SORT_HPP + +#include +#include +#include +#include +#include + +namespace boost { + + + // Topological sort visitor + // + // This visitor merely writes the linear ordering into an + // OutputIterator. The OutputIterator could be something like an + // ostream_iterator, or it could be a back/front_insert_iterator. + // Note that if it is a back_insert_iterator, the recorded order is + // the reverse topological order. On the other hand, if it is a + // front_insert_iterator, the recorded order is the topological + // order. + // + template + struct topo_sort_visitor : public dfs_visitor<> + { + topo_sort_visitor(OutputIterator _iter) + : m_iter(_iter) { } + + template + void back_edge(const Edge& u, Graph&) { throw not_a_dag(); } + + template + void finish_vertex(const Vertex& u, Graph&) { *m_iter++ = u; } + + OutputIterator m_iter; + }; + + + // Topological Sort + // + // The topological sort algorithm creates a linear ordering + // of the vertices such that if edge (u,v) appears in the graph, + // then u comes before v in the ordering. The graph must + // be a directed acyclic graph (DAG). The implementation + // consists mainly of a call to depth-first search. + // + + template + void topological_sort(VertexListGraph& g, OutputIterator result, + const bgl_named_params& params) + { + typedef topo_sort_visitor TopoVisitor; + depth_first_search(g, params.visitor(TopoVisitor(result))); + } + + template + void topological_sort(VertexListGraph& g, OutputIterator result) + { + topological_sort(g, result, + bgl_named_params(0)); // bogus + } + +} // namespace boost + +#endif /*BOOST_GRAPH_TOPOLOGICAL_SORT_H*/ diff --git a/deal.II/contrib/boost/include/boost/graph/transitive_closure.hpp b/deal.II/contrib/boost/include/boost/graph/transitive_closure.hpp new file mode 100644 index 0000000000..a4742ab155 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/transitive_closure.hpp @@ -0,0 +1,370 @@ +// Copyright (C) 2001 Vladimir Prus +// Copyright (C) 2001 Jeremy Siek +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// NOTE: this final is generated by libs/graph/doc/transitive_closure.w + +#ifndef BOOST_GRAPH_TRANSITIVE_CLOSURE_HPP +#define BOOST_GRAPH_TRANSITIVE_CLOSURE_HPP + +#include +#include // for std::min and std::max +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace detail + { + inline void + union_successor_sets(const std::vector < std::size_t > &s1, + const std::vector < std::size_t > &s2, + std::vector < std::size_t > &s3) + { + BOOST_USING_STD_MIN(); + for (std::size_t k = 0; k < s1.size(); ++k) + s3[k] = min BOOST_PREVENT_MACRO_SUBSTITUTION(s1[k], s2[k]); + } + } // namespace detail + + namespace detail + { + template < typename Container, typename ST = std::size_t, + typename VT = typename Container::value_type > + struct subscript_t:public std::unary_function < ST, VT > + { + typedef VT& result_type; + + subscript_t(Container & c):container(&c) + { + } + VT & operator() (const ST & i) const + { + return (*container)[i]; + } + protected: + Container * container; + }; + template < typename Container > + subscript_t < Container > subscript(Container & c) { + return subscript_t < Container > (c); + } + } // namespace detail + + template < typename Graph, typename GraphTC, + typename G_to_TC_VertexMap, + typename VertexIndexMap > + void transitive_closure(const Graph & g, GraphTC & tc, + G_to_TC_VertexMap g_to_tc_map, + VertexIndexMap index_map) + { + if (num_vertices(g) == 0) + return; + typedef typename graph_traits < Graph >::vertex_descriptor vertex; + typedef typename graph_traits < Graph >::edge_descriptor edge; + typedef typename graph_traits < Graph >::vertex_iterator vertex_iterator; + typedef typename property_traits < VertexIndexMap >::value_type size_type; + typedef typename graph_traits < + Graph >::adjacency_iterator adjacency_iterator; + + function_requires < VertexListGraphConcept < Graph > >(); + function_requires < AdjacencyGraphConcept < Graph > >(); + function_requires < VertexMutableGraphConcept < GraphTC > >(); + function_requires < EdgeMutableGraphConcept < GraphTC > >(); + function_requires < ReadablePropertyMapConcept < VertexIndexMap, + vertex > >(); + + typedef size_type cg_vertex; + std::vector < cg_vertex > component_number_vec(num_vertices(g)); + iterator_property_map < cg_vertex *, VertexIndexMap, cg_vertex, cg_vertex& > + component_number(&component_number_vec[0], index_map); + + int num_scc = strong_components(g, component_number, + vertex_index_map(index_map)); + + std::vector < std::vector < vertex > >components; + build_component_lists(g, num_scc, component_number, components); + + typedef std::vector > CG_t; + CG_t CG(num_scc); + for (cg_vertex s = 0; s < components.size(); ++s) { + std::vector < cg_vertex > adj; + for (size_type i = 0; i < components[s].size(); ++i) { + vertex u = components[s][i]; + adjacency_iterator v, v_end; + for (tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) { + cg_vertex t = component_number[*v]; + if (s != t) // Avoid loops in the condensation graph + adj.push_back(t); + } + } + std::sort(adj.begin(), adj.end()); + typename std::vector::iterator di = + std::unique(adj.begin(), adj.end()); + if (di != adj.end()) + adj.erase(di, adj.end()); + CG[s] = adj; + } + + std::vector topo_order; + std::vector topo_number(num_vertices(CG)); + topological_sort(CG, std::back_inserter(topo_order), + vertex_index_map(identity_property_map())); + std::reverse(topo_order.begin(), topo_order.end()); + size_type n = 0; + for (typename std::vector::iterator iter = topo_order.begin(); + iter != topo_order.end(); ++iter) + topo_number[*iter] = n++; + + for (size_type i = 0; i < num_vertices(CG); ++i) + std::sort(CG[i].begin(), CG[i].end(), + boost::bind(std::less(), + boost::bind(detail::subscript(topo_number), _1), + boost::bind(detail::subscript(topo_number), _2))); + + std::vector > chains; + { + std::vector in_a_chain(num_vertices(CG)); + for (typename std::vector::iterator i = topo_order.begin(); + i != topo_order.end(); ++i) { + cg_vertex v = *i; + if (!in_a_chain[v]) { + chains.resize(chains.size() + 1); + std::vector& chain = chains.back(); + for (;;) { + chain.push_back(v); + in_a_chain[v] = true; + typename graph_traits::adjacency_iterator adj_first, adj_last; + tie(adj_first, adj_last) = adjacent_vertices(v, CG); + typename graph_traits::adjacency_iterator next + = std::find_if(adj_first, adj_last, + std::not1(detail::subscript(in_a_chain))); + if (next != adj_last) + v = *next; + else + break; // end of chain, dead-end + + } + } + } + } + std::vector chain_number(num_vertices(CG)); + std::vector pos_in_chain(num_vertices(CG)); + for (size_type i = 0; i < chains.size(); ++i) + for (size_type j = 0; j < chains[i].size(); ++j) { + cg_vertex v = chains[i][j]; + chain_number[v] = i; + pos_in_chain[v] = j; + } + + cg_vertex inf = (std::numeric_limits< cg_vertex >::max)(); + std::vector > successors(num_vertices(CG), + std::vector + (chains.size(), inf)); + for (typename std::vector::reverse_iterator + i = topo_order.rbegin(); i != topo_order.rend(); ++i) { + cg_vertex u = *i; + typename graph_traits::adjacency_iterator adj, adj_last; + for (tie(adj, adj_last) = adjacent_vertices(u, CG); + adj != adj_last; ++adj) { + cg_vertex v = *adj; + if (topo_number[v] < successors[u][chain_number[v]]) { + // Succ(u) = Succ(u) U Succ(v) + detail::union_successor_sets(successors[u], successors[v], + successors[u]); + // Succ(u) = Succ(u) U {v} + successors[u][chain_number[v]] = topo_number[v]; + } + } + } + + for (size_type i = 0; i < CG.size(); ++i) + CG[i].clear(); + for (size_type i = 0; i < CG.size(); ++i) + for (size_type j = 0; j < chains.size(); ++j) { + size_type topo_num = successors[i][j]; + if (topo_num < inf) { + cg_vertex v = topo_order[topo_num]; + for (size_type k = pos_in_chain[v]; k < chains[j].size(); ++k) + CG[i].push_back(chains[j][k]); + } + } + + + // Add vertices to the transitive closure graph + typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex; + { + vertex_iterator i, i_end; + for (tie(i, i_end) = vertices(g); i != i_end; ++i) + g_to_tc_map[*i] = add_vertex(tc); + } + // Add edges between all the vertices in two adjacent SCCs + typename graph_traits::vertex_iterator si, si_end; + for (tie(si, si_end) = vertices(CG); si != si_end; ++si) { + cg_vertex s = *si; + typename graph_traits::adjacency_iterator i, i_end; + for (tie(i, i_end) = adjacent_vertices(s, CG); i != i_end; ++i) { + cg_vertex t = *i; + for (size_type k = 0; k < components[s].size(); ++k) + for (size_type l = 0; l < components[t].size(); ++l) + add_edge(g_to_tc_map[components[s][k]], + g_to_tc_map[components[t][l]], tc); + } + } + // Add edges connecting all vertices in a SCC + for (size_type i = 0; i < components.size(); ++i) + if (components[i].size() > 1) + for (size_type k = 0; k < components[i].size(); ++k) + for (size_type l = 0; l < components[i].size(); ++l) { + vertex u = components[i][k], v = components[i][l]; + add_edge(g_to_tc_map[u], g_to_tc_map[v], tc); + } + + // Find loopbacks in the original graph. + // Need to add it to transitive closure. + { + vertex_iterator i, i_end; + for (tie(i, i_end) = vertices(g); i != i_end; ++i) + { + adjacency_iterator ab, ae; + for (boost::tie(ab, ae) = adjacent_vertices(*i, g); ab != ae; ++ab) + { + if (*ab == *i) + if (components[component_number[*i]].size() == 1) + add_edge(g_to_tc_map[*i], g_to_tc_map[*i], tc); + } + } + } + } + + template + void transitive_closure(const Graph & g, GraphTC & tc) + { + if (num_vertices(g) == 0) + return; + typedef typename property_map::const_type + VertexIndexMap; + VertexIndexMap index_map = get(vertex_index, g); + + typedef typename graph_traits::vertex_descriptor tc_vertex; + std::vector to_tc_vec(num_vertices(g)); + iterator_property_map < tc_vertex *, VertexIndexMap, tc_vertex, tc_vertex&> + g_to_tc_map(&to_tc_vec[0], index_map); + + transitive_closure(g, tc, g_to_tc_map, index_map); + } + + namespace detail + { + template < typename Graph, typename GraphTC, typename G_to_TC_VertexMap, + typename VertexIndexMap> + void transitive_closure_dispatch + (const Graph & g, GraphTC & tc, + G_to_TC_VertexMap g_to_tc_map, VertexIndexMap index_map) + { + typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex; + typename std::vector < tc_vertex >::size_type + n = is_default_param(g_to_tc_map) ? num_vertices(g) : 1; + std::vector < tc_vertex > to_tc_vec(n); + + transitive_closure + (g, tc, + choose_param(g_to_tc_map, make_iterator_property_map + (to_tc_vec.begin(), index_map, to_tc_vec[0])), + index_map); + } + } // namespace detail + + template < typename Graph, typename GraphTC, + typename P, typename T, typename R > + void transitive_closure(const Graph & g, GraphTC & tc, + const bgl_named_params < P, T, R > ¶ms) + { + if (num_vertices(g) == 0) + return; + detail::transitive_closure_dispatch + (g, tc, get_param(params, orig_to_copy_t()), + choose_const_pmap(get_param(params, vertex_index), g, vertex_index) ); + } + + + template < typename G > void warshall_transitive_closure(G & g) + { + typedef typename graph_traits < G >::vertex_descriptor vertex; + typedef typename graph_traits < G >::vertex_iterator vertex_iterator; + + function_requires < AdjacencyMatrixConcept < G > >(); + function_requires < EdgeMutableGraphConcept < G > >(); + + // Matrix form: + // for k + // for i + // if A[i,k] + // for j + // A[i,j] = A[i,j] | A[k,j] + vertex_iterator ki, ke, ii, ie, ji, je; + for (tie(ki, ke) = vertices(g); ki != ke; ++ki) + for (tie(ii, ie) = vertices(g); ii != ie; ++ii) + if (edge(*ii, *ki, g).second) + for (tie(ji, je) = vertices(g); ji != je; ++ji) + if (!edge(*ii, *ji, g).second && edge(*ki, *ji, g).second) { + add_edge(*ii, *ji, g); + } + } + + + template < typename G > void warren_transitive_closure(G & g) + { + using namespace boost; + typedef typename graph_traits < G >::vertex_descriptor vertex; + typedef typename graph_traits < G >::vertex_iterator vertex_iterator; + + function_requires < AdjacencyMatrixConcept < G > >(); + function_requires < EdgeMutableGraphConcept < G > >(); + + // Make sure second loop will work + if (num_vertices(g) == 0) + return; + + // for i = 2 to n + // for k = 1 to i - 1 + // if A[i,k] + // for j = 1 to n + // A[i,j] = A[i,j] | A[k,j] + + vertex_iterator ic, ie, jc, je, kc, ke; + for (tie(ic, ie) = vertices(g), ++ic; ic != ie; ++ic) + for (tie(kc, ke) = vertices(g); *kc != *ic; ++kc) + if (edge(*ic, *kc, g).second) + for (tie(jc, je) = vertices(g); jc != je; ++jc) + if (!edge(*ic, *jc, g).second && edge(*kc, *jc, g).second) { + add_edge(*ic, *jc, g); + } + // for i = 1 to n - 1 + // for k = i + 1 to n + // if A[i,k] + // for j = 1 to n + // A[i,j] = A[i,j] | A[k,j] + + for (tie(ic, ie) = vertices(g), --ie; ic != ie; ++ic) + for (kc = ic, ke = ie, ++kc; kc != ke; ++kc) + if (edge(*ic, *kc, g).second) + for (tie(jc, je) = vertices(g); jc != je; ++jc) + if (!edge(*ic, *jc, g).second && edge(*kc, *jc, g).second) { + add_edge(*ic, *jc, g); + } + } + + +} // namespace boost + +#endif // BOOST_GRAPH_TRANSITIVE_CLOSURE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/transpose_graph.hpp b/deal.II/contrib/boost/include/boost/graph/transpose_graph.hpp new file mode 100644 index 0000000000..b12ba1005d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/transpose_graph.hpp @@ -0,0 +1,40 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_TRANSPOSE_HPP +#define BOOST_GRAPH_TRANSPOSE_HPP + +#include +#include +#include +#include + + +namespace boost { + + template + void transpose_graph(const VertexListGraph& G, MutableGraph& G_T) + { + reverse_graph R(G); + copy_graph(R, G_T); + } + + template + void transpose_graph(const VertexListGraph& G, MutableGraph& G_T, + const bgl_named_params& params) + { + reverse_graph Rev(G); + copy_graph(Rev, G_T, params); + } + +} // namespace boost + +#endif // BOOST_GRAPH_TRANSPOSE_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/tree_traits.hpp b/deal.II/contrib/boost/include/boost/graph/tree_traits.hpp new file mode 100644 index 0000000000..a9f7e8ce1b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/tree_traits.hpp @@ -0,0 +1,43 @@ +// (C) Copyright Jeremy Siek 1999. +// 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_TREE_STRUCTURE_HPP +#define BOOST_TREE_STRUCTURE_HPP + +namespace boost { + + template + struct tree_traits { + typedef typename T::node_descriptor node_descriptor; + typedef typename T::children_iterator children_iterator; + }; + + + template + void traverse_tree(typename tree_traits::node_descriptor v, + Tree& t, TreeVisitor visitor) + { + visitor.preorder(v, t); + typename tree_traits::children_iterator i, end; + tie(i, end) = children(v, t); + if (i != end) { + traverse_tree(*i++, t, visitor); + visitor.inorder(v, t); + while (i != end) + traverse_tree(*i++, t, visitor); + } else + visitor.inorder(v, t); + visitor.postorder(v, t); + } + + struct null_tree_visitor { + template void preorder(Node, Tree&) { } + template void inorder(Node, Tree&) { } + template void postorder(Node, Tree&) { } + }; + +} /* namespace boost */ + +#endif /* BOOST_TREE_STRUCTURE_HPP */ diff --git a/deal.II/contrib/boost/include/boost/graph/undirected_dfs.hpp b/deal.II/contrib/boost/include/boost/graph/undirected_dfs.hpp new file mode 100644 index 0000000000..2486cd4b69 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/undirected_dfs.hpp @@ -0,0 +1,250 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_UNDIRECTED_DFS_HPP +#define BOOST_GRAPH_UNDIRECTED_DFS_HPP + +#include +#include + +namespace boost { + + namespace detail { + +// Define BOOST_RECURSIVE_DFS to use older, recursive version. +// It is retained for a while in order to perform performance +// comparison. +#ifndef BOOST_RECURSIVE_DFS + + template + void undir_dfv_impl + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor& vis, + VertexColorMap vertex_color, + EdgeColorMap edge_color) + { + function_requires >(); + function_requires >(); + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename graph_traits::edge_descriptor Edge; + function_requires >(); + function_requires >(); + typedef typename property_traits::value_type ColorValue; + typedef typename property_traits::value_type EColorValue; + function_requires< ColorValueConcept >(); + function_requires< ColorValueConcept >(); + typedef color_traits Color; + typedef color_traits EColor; + typedef typename graph_traits::out_edge_iterator Iter; + typedef std::pair > VertexInfo; + + std::vector stack; + + put(vertex_color, u, Color::gray()); + vis.discover_vertex(u, g); + stack.push_back(std::make_pair(u, out_edges(u, g))); + while (!stack.empty()) { + VertexInfo& back = stack.back(); + u = back.first; + Iter ei, ei_end; + tie(ei, ei_end) = back.second; + stack.pop_back(); + while (ei != ei_end) { + Vertex v = target(*ei, g); + vis.examine_edge(*ei, g); + ColorValue v_color = get(vertex_color, v); + EColorValue uv_color = get(edge_color, *ei); + put(edge_color, *ei, EColor::black()); + if (v_color == Color::white()) { + vis.tree_edge(*ei, g); + stack.push_back(std::make_pair(u, std::make_pair(++ei, ei_end))); + u = v; + put(vertex_color, u, Color::gray()); + vis.discover_vertex(u, g); + tie(ei, ei_end) = out_edges(u, g); + } else if (v_color == Color::gray()) { + if (uv_color == EColor::white()) vis.back_edge(*ei, g); + ++ei; + } else { // if (v_color == Color::black()) + ++ei; + } + } + put(vertex_color, u, Color::black()); + vis.finish_vertex(u, g); + } + } + +#else // BOOST_RECURSIVE_DFS + + template + void undir_dfv_impl + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor& vis, // pass-by-reference here, important! + VertexColorMap vertex_color, + EdgeColorMap edge_color) + { + function_requires >(); + function_requires >(); + typedef typename graph_traits::vertex_descriptor Vertex; + typedef typename graph_traits::edge_descriptor Edge; + function_requires >(); + function_requires >(); + typedef typename property_traits::value_type ColorValue; + typedef typename property_traits::value_type EColorValue; + function_requires< ColorValueConcept >(); + function_requires< ColorValueConcept >(); + typedef color_traits Color; + typedef color_traits EColor; + typename graph_traits::out_edge_iterator ei, ei_end; + + put(vertex_color, u, Color::gray()); vis.discover_vertex(u, g); + for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { + Vertex v = target(*ei, g); vis.examine_edge(*ei, g); + ColorValue v_color = get(vertex_color, v); + EColorValue uv_color = get(edge_color, *ei); + put(edge_color, *ei, EColor::black()); + if (v_color == Color::white()) { vis.tree_edge(*ei, g); + undir_dfv_impl(g, v, vis, vertex_color, edge_color); + } else if (v_color == Color::gray() && uv_color == EColor::white()) + vis.back_edge(*ei, g); + } + put(vertex_color, u, Color::black()); vis.finish_vertex(u, g); + } + +#endif // ! BOOST_RECURSIVE_DFS + + } // namespace detail + + template + void + undirected_dfs(const Graph& g, DFSVisitor vis, + VertexColorMap vertex_color, EdgeColorMap edge_color, + Vertex start_vertex) + { + function_requires >(); + function_requires >(); + + typedef typename property_traits::value_type ColorValue; + typedef color_traits Color; + + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + put(vertex_color, *ui, Color::white()); vis.initialize_vertex(*ui, g); + } + typename graph_traits::edge_iterator ei, ei_end; + for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) + put(edge_color, *ei, Color::white()); + + if (start_vertex != *vertices(g).first){ vis.start_vertex(start_vertex, g); + detail::undir_dfv_impl(g, start_vertex, vis, vertex_color, edge_color); + } + + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { + ColorValue u_color = get(vertex_color, *ui); + if (u_color == Color::white()) { vis.start_vertex(*ui, g); + detail::undir_dfv_impl(g, *ui, vis, vertex_color, edge_color); + } + } + } + + template + void + undirected_dfs(const Graph& g, DFSVisitor vis, + VertexColorMap vertex_color, EdgeColorMap edge_color) + { + undirected_dfs(g, vis, vertex_color, edge_color, *vertices(g).first); + } + + namespace detail { + template + struct udfs_dispatch { + + template + static void + apply(const Graph& g, DFSVisitor vis, Vertex start_vertex, + const bgl_named_params&, + EdgeColorMap edge_color, + VertexColorMap vertex_color) + { + undirected_dfs(g, vis, vertex_color, edge_color, start_vertex); + } + }; + + template <> + struct udfs_dispatch { + template + static void + apply(const Graph& g, DFSVisitor vis, Vertex start_vertex, + const bgl_named_params& params, + EdgeColorMap edge_color, + detail::error_property_not_found) + { + std::vector color_vec(num_vertices(g)); + default_color_type c = white_color; // avoid warning about un-init + undirected_dfs + (g, vis, make_iterator_property_map + (color_vec.begin(), + choose_const_pmap(get_param(params, vertex_index), + g, vertex_index), c), + edge_color, + start_vertex); + } + }; + + } // namespace detail + + + // Named Parameter Variant + template + void + undirected_dfs(const Graph& g, + const bgl_named_params& params) + { + typedef typename property_value< bgl_named_params, + vertex_color_t>::type C; + detail::udfs_dispatch::apply + (g, + choose_param(get_param(params, graph_visitor), + make_dfs_visitor(null_visitor())), + choose_param(get_param(params, root_vertex_t()), + *vertices(g).first), + params, + get_param(params, edge_color), + get_param(params, vertex_color) + ); + } + + + template + void undirected_depth_first_visit + (const IncidenceGraph& g, + typename graph_traits::vertex_descriptor u, + DFSVisitor vis, VertexColorMap vertex_color, EdgeColorMap edge_color) + { + detail::undir_dfv_impl(g, u, vis, vertex_color, edge_color); + } + + +} // namespace boost + + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/vector_as_graph.hpp b/deal.II/contrib/boost/include/boost/graph/vector_as_graph.hpp new file mode 100644 index 0000000000..5f9e8af1f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/vector_as_graph.hpp @@ -0,0 +1,309 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Copyright (C) 2001 Vladimir Prus +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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) +//======================================================================= + +// The mutating functions (add_edge, etc.) were added by Vladimir Prus. + +#ifndef BOOST_VECTOR_AS_GRAPH_HPP +#define BOOST_VECTOR_AS_GRAPH_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +/* + This module implements the VertexListGraph concept using a + std::vector as the "back-bone" of the graph (the vector *is* the + graph object). The edge-lists type of the graph is templated, so the + user can choose any STL container, so long as the value_type of the + container is convertible to the size_type of the vector. For now any + graph properties must be stored seperately. + + This module requires the C++ compiler to support partial + specialization for the graph_traits class, so this is not portable + to VC++. + +*/ + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#error The vector-as-graph module requires a compiler that supports partial specialization +#endif + + +namespace boost { + namespace detail { + template struct val_out_edge_ret; + template struct val_out_edge_iter; + template struct val_edge; + } +} + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace boost { + + struct vector_as_graph_traversal_tag + : public vertex_list_graph_tag, + public adjacency_graph_tag, + public incidence_graph_tag { }; + + template + struct graph_traits< std::vector > + { + typedef typename EdgeList::value_type V; + typedef V vertex_descriptor; + typedef typename detail::val_edge::type edge_descriptor; + typedef typename EdgeList::const_iterator adjacency_iterator; + typedef typename detail::val_out_edge_iter::type + out_edge_iterator; + typedef void in_edge_iterator; + typedef void edge_iterator; + typedef typename integer_range::iterator vertex_iterator; + typedef directed_tag directed_category; + typedef allow_parallel_edge_tag edge_parallel_category; + typedef vector_as_graph_traversal_tag traversal_category; + typedef typename std::vector::size_type vertices_size_type; + typedef void edges_size_type; + typedef typename EdgeList::size_type degree_size_type; + }; + template + struct edge_property_type< std::vector > + { + typedef void type; + }; + template + struct vertex_property_type< std::vector > + { + typedef void type; + }; + template + struct graph_property_type< std::vector > + { + typedef void type; + }; +} +#endif + +namespace boost { + + namespace detail { + + // "val" is short for Vector Adjacency List + + template + struct val_edge + { + typedef typename EdgeList::value_type V; + typedef std::pair type; + }; + + // need rewrite this using boost::iterator_adaptor + template + class val_out_edge_iterator + : public boost::iterator, + std::ptrdiff_t, std::pair*, const std::pair > + { + typedef val_out_edge_iterator self; + typedef std::pair Edge; + public: + val_out_edge_iterator() { } + val_out_edge_iterator(V s, Iter i) : _source(s), _iter(i) { } + Edge operator*() const { return Edge(_source, *_iter); } + self& operator++() { ++_iter; return *this; } + self operator++(int) { self t = *this; ++_iter; return t; } + bool operator==(const self& x) const { return _iter == x._iter; } + bool operator!=(const self& x) const { return _iter != x._iter; } + protected: + V _source; + Iter _iter; + }; + + template + struct val_out_edge_iter + { + typedef typename EdgeList::value_type V; + typedef typename EdgeList::const_iterator Iter; + typedef val_out_edge_iterator type; + }; + + template + struct val_out_edge_ret + { + typedef typename val_out_edge_iter::type IncIter; + typedef std::pair type; + }; + + } // namesapce detail + + template + typename detail::val_out_edge_ret::type + out_edges(typename EdgeList::value_type v, + const std::vector& g) + { + typedef typename detail::val_out_edge_iter::type Iter; + typedef typename detail::val_out_edge_ret::type return_type; + return return_type(Iter(v, g[v].begin()), Iter(v, g[v].end())); + } + + template + typename EdgeList::size_type + out_degree(typename EdgeList::value_type v, + const std::vector& g) + { + return g[v].size(); + } + + template + std::pair + adjacent_vertices(typename EdgeList::value_type v, + const std::vector& g) + { + return std::make_pair(g[v].begin(), g[v].end()); + } + + // source() and target() already provided for pairs in graph_traits.hpp + + template + std::pair + ::iterator, + typename boost::integer_range + ::iterator > + vertices(const std::vector& v) + { + typedef typename boost::integer_range + ::iterator Iter; + return std::make_pair(Iter(0), Iter(v.size())); + } + + template + typename std::vector::size_type + num_vertices(const std::vector& v) + { + return v.size(); + } + + template + typename std::pair::type, bool> + add_edge(typename EdgeList::value_type u, typename EdgeList::value_type v, + std::vector& g) + { + typedef typename detail::val_edge::type edge_type; + g[u].insert(g[u].end(), v); + return std::make_pair(edge_type(u, v), true); + } + + template + typename std::pair::type, bool> + edge(typename EdgeList::value_type u, typename EdgeList::value_type v, + std::vector& g) + { + typedef typename detail::val_edge::type edge_type; + typename EdgeList::iterator i = g[u].begin(), end = g[u].end(); + for (; i != end; ++i) + if (*i == v) + return std::make_pair(edge_type(u, v), true); + return std::make_pair(edge_type(), false); + } + + template + void + remove_edge(typename EdgeList::value_type u, typename EdgeList::value_type v, + std::vector& g) + { + typename EdgeList::iterator i = std::remove(g[u].begin(), g[u].end(), v); + if (i != g[u].end()) + g[u].erase(i, g[u].end()); + } + + template + void + remove_edge(typename detail::val_edge::type e, + std::vector& g) + { + typename EdgeList::value_type u, v; + u = e.first; + v = e.second; + // FIXME: edge type does not fully specify the edge to be deleted + typename EdgeList::iterator i = std::remove(g[u].begin(), g[u].end(), v); + if (i != g[u].end()) + g[u].erase(i, g[u].end()); + } + + template + void + remove_edge_if(Predicate p, + std::vector& g) + { + for (std::size_t u = 0; u < g.size(); ++u) { + // Oops! gcc gets internal compiler error on compose_....... + + typedef typename EdgeList::iterator iterator; + iterator b = g[u].begin(), e = g[u].end(); + + if (!g[u].empty()) { + + for(; b != e;) { + if (p(std::make_pair(u, *b))) { + --e; + if (b == e) + break; + else + iter_swap(b, e); + } else { + ++b; + } + } + } + + if (e != g[u].end()) + g[u].erase(e, g[u].end()); + } + } + + template + typename EdgeList::value_type + add_vertex(std::vector& g) + { + g.resize(g.size()+1); + return g.size()-1; + } + + template + void + clear_vertex(typename EdgeList::value_type u, + std::vector& g) + { + g[u].clear(); + for (std::size_t i = 0; i < g.size(); ++i) + remove_edge(i, u, g); + } + + template + void + remove_vertex(typename EdgeList::value_type u, + std::vector& g) + { + typedef typename EdgeList::iterator iterator; + clear_vertex(u, g); + g.erase(g.begin() + u); + for (std::size_t i = 0; i < g.size(); ++i) + for ( iterator it = g[i].begin(); it != g[i].end(); ++it ) + // after clear_vertex *it is never equal to u + if ( *it > u ) + --*it; + } + +} // namespace boost + +#endif // BOOST_VECTOR_AS_GRAPH_HPP diff --git a/deal.II/contrib/boost/include/boost/graph/visitors.hpp b/deal.II/contrib/boost/include/boost/graph/visitors.hpp new file mode 100644 index 0000000000..892f0241e3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/visitors.hpp @@ -0,0 +1,269 @@ +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +//======================================================================= +// +// Revision History: +// 01 April 2001: Modified to use new header. (JMaddock) +// +#ifndef BOOST_GRAPH_GRAPH_SEARCH_VISITORS_HPP +#define BOOST_GRAPH_GRAPH_SEARCH_VISITORS_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + + // This is a bit more convenient than std::numeric_limits because + // you don't have to explicitly provide type T. + template + inline T numeric_limits_max(T) { return (std::numeric_limits::max)(); } + + //======================================================================== + // Event Tags + + namespace detail { + // For partial specialization workaround + enum event_visitor_enum + { on_no_event_num, + on_initialize_vertex_num, on_start_vertex_num, + on_discover_vertex_num, on_finish_vertex_num, on_examine_vertex_num, + on_examine_edge_num, on_tree_edge_num, on_non_tree_edge_num, + on_gray_target_num, on_black_target_num, + on_forward_or_cross_edge_num, on_back_edge_num, + on_edge_relaxed_num, on_edge_not_relaxed_num, + on_edge_minimized_num, on_edge_not_minimized_num + }; + + template + struct functor_to_visitor : Visitor + { + typedef Event event_filter; + functor_to_visitor(const Visitor& visitor) : Visitor(visitor) {} + }; + + } // namespace detail + + struct on_no_event { enum { num = detail::on_no_event_num }; }; + + struct on_initialize_vertex { + enum { num = detail::on_initialize_vertex_num }; }; + struct on_start_vertex { enum { num = detail::on_start_vertex_num }; }; + struct on_discover_vertex { enum { num = detail::on_discover_vertex_num }; }; + struct on_examine_vertex { enum { num = detail::on_examine_vertex_num }; }; + struct on_finish_vertex { enum { num = detail::on_finish_vertex_num }; }; + + struct on_examine_edge { enum { num = detail::on_examine_edge_num }; }; + struct on_tree_edge { enum { num = detail::on_tree_edge_num }; }; + struct on_non_tree_edge { enum { num = detail::on_non_tree_edge_num }; }; + struct on_gray_target { enum { num = detail::on_gray_target_num }; }; + struct on_black_target { enum { num = detail::on_black_target_num }; }; + struct on_forward_or_cross_edge { + enum { num = detail::on_forward_or_cross_edge_num }; }; + struct on_back_edge { enum { num = detail::on_back_edge_num }; }; + + struct on_edge_relaxed { enum { num = detail::on_edge_relaxed_num }; }; + struct on_edge_not_relaxed { + enum { num = detail::on_edge_not_relaxed_num }; }; + struct on_edge_minimized { enum { num = detail::on_edge_minimized_num }; }; + struct on_edge_not_minimized { + enum { num = detail::on_edge_not_minimized_num }; }; + + struct true_tag { enum { num = true }; }; + struct false_tag { enum { num = false }; }; + + //======================================================================== + // base_visitor and null_visitor + + // needed for MSVC workaround + template + struct base_visitor { + typedef on_no_event event_filter; + template + void operator()(T, Graph&) { } + }; + + struct null_visitor : public base_visitor { + typedef on_no_event event_filter; + template + void operator()(T, Graph&) { } + }; + + //======================================================================== + // The invoke_visitors() function + + namespace detail { + template + inline void + invoke_dispatch(Visitor& v, T x, Graph& g, true_tag) { + v(x, g); + } + template + inline void + invoke_dispatch(Visitor&, T, Graph&, false_tag) { } + } // namespace detail + + template + inline void + invoke_visitors(std::pair& vlist, T x, Graph& g, Tag tag) { + typedef typename Visitor::event_filter Category; + typedef typename graph_detail::is_same::is_same_tag + IsSameTag; + detail::invoke_dispatch(vlist.first, x, g, IsSameTag()); + invoke_visitors(vlist.second, x, g, tag); + } +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 + template + inline void + invoke_visitors(base_visitor& vis, T x, Graph& g, Tag) { + typedef typename Visitor::event_filter Category; + typedef typename graph_detail::is_same::is_same_tag + IsSameTag; + Visitor& v = static_cast(vis); + detail::invoke_dispatch(v, x, g, IsSameTag()); + } +#else + template + inline void + invoke_visitors(Visitor& v, T x, Graph& g, Tag) { + typedef typename Visitor::event_filter Category; + typedef typename graph_detail::is_same::is_same_tag + IsSameTag; + detail::invoke_dispatch(v, x, g, IsSameTag()); + } +#endif + + //======================================================================== + // predecessor_recorder + + template + struct predecessor_recorder + : public base_visitor > + { + typedef Tag event_filter; + predecessor_recorder(PredecessorMap pa) : m_predecessor(pa) { } + template + void operator()(Edge e, const Graph& g) { + put(m_predecessor, target(e, g), source(e, g)); + } + PredecessorMap m_predecessor; + }; + template + predecessor_recorder + record_predecessors(PredecessorMap pa, Tag) { + return predecessor_recorder (pa); + } + + //======================================================================== + // edge_predecessor_recorder + + template + struct edge_predecessor_recorder + : public base_visitor > + { + typedef Tag event_filter; + edge_predecessor_recorder(PredEdgeMap pa) : m_predecessor(pa) { } + template + void operator()(Edge e, const Graph& g) { + put(m_predecessor, target(e, g), e); + } + PredEdgeMap m_predecessor; + }; + template + edge_predecessor_recorder + record_edge_predecessors(PredEdgeMap pa, Tag) { + return edge_predecessor_recorder (pa); + } + + //======================================================================== + // distance_recorder + + template + struct distance_recorder + : public base_visitor > + { + typedef Tag event_filter; + distance_recorder(DistanceMap pa) : m_distance(pa) { } + template + void operator()(Edge e, const Graph& g) { + typename graph_traits::vertex_descriptor + u = source(e, g), v = target(e, g); + put(m_distance, v, get(m_distance, u) + 1); + } + DistanceMap m_distance; + }; + template + distance_recorder + record_distances(DistanceMap pa, Tag) { + return distance_recorder (pa); + } + + //======================================================================== + // time_stamper + + + template + struct time_stamper + : public base_visitor > + { + typedef Tag event_filter; + time_stamper(TimeMap pa, TimeT& t) : m_time_pa(pa), m_time(t) { } + template + void operator()(Vertex u, const Graph&) { + put(m_time_pa, u, ++m_time); + } + TimeMap m_time_pa; + TimeT& m_time; + }; + template + time_stamper + stamp_times(TimeMap pa, TimeT& time_counter, Tag) { + return time_stamper(pa, time_counter); + } + + //======================================================================== + // property_writer + + template + struct property_writer + : public base_visitor > + { + typedef Tag event_filter; + + property_writer(PA pa, OutputIterator out) : m_pa(pa), m_out(out) { } + + template + void operator()(T x, Graph&) { *m_out++ = get(m_pa, x); } + PA m_pa; + OutputIterator m_out; + }; + template + property_writer + write_property(PA pa, OutputIterator out, Tag) { + return property_writer(pa, out); + } + +#define BOOST_GRAPH_EVENT_STUB(Event,Kind) \ + typedef ::boost::Event Event##_type; \ + template \ + Kind##_visitor, Visitors> > \ + do_##Event(Visitor visitor) \ + { \ + typedef std::pair, \ + Visitors> visitor_list; \ + typedef Kind##_visitor result_type; \ + return result_type(visitor_list(visitor, m_vis)); \ + } + +} /* namespace boost */ + +#endif diff --git a/deal.II/contrib/boost/include/boost/graph/wavefront.hpp b/deal.II/contrib/boost/include/boost/graph/wavefront.hpp new file mode 100755 index 0000000000..e28ab69e33 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/graph/wavefront.hpp @@ -0,0 +1,151 @@ +// +//======================================================================= +// Copyright 2002 Marc Wintermantel (wintermantel@imes.mavt.ethz.ch) +// ETH Zurich, Center of Structure Technologies (www.imes.ethz.ch/st) +// +// This file is part of the Boost Graph Library +// +// You should have received a copy of the License Agreement for the +// Boost Graph Library along with the software; see the file LICENSE. +// If not, contact Office of Research, University of Notre Dame, Notre +// Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// + +#ifndef BOOST_GRAPH_WAVEFRONT_HPP +#define BOOST_GRAPH_WAVEFRONT_HPP + +#include +#include +#include +#include +#include +#include +#include // for std::min and std::max + +namespace boost { + + template + typename graph_traits::vertices_size_type + ith_wavefront(typename graph_traits::vertex_descriptor i, + const Graph& g, + VertexIndexMap index) + { + typename graph_traits::vertex_descriptor v, w; + typename graph_traits::vertices_size_type b = 1; + typename graph_traits::out_edge_iterator edge_it2, edge_it2_end; + typename graph_traits::vertices_size_type index_i = index[i]; + std::vector rows_active(num_vertices(g), false); + + rows_active[index_i] = true; + + typename graph_traits::vertex_iterator ui, ui_end; + for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) + { + v = *ui; + if(index[v] <= index_i) + { + for (tie(edge_it2, edge_it2_end) = out_edges(v, g); edge_it2 != edge_it2_end; ++edge_it2) + { + w = target(*edge_it2, g); + if( (index[w] >= index_i) && (!rows_active[index[w]]) ) + { + b++; + rows_active[index[w]] = true; + } + } + } + } + + return b; + } + + + template + typename graph_traits::vertices_size_type + ith_wavefront(typename graph_traits::vertex_descriptor i, + const Graph& g) + { + return ith_wavefront(i, g, get(vertex_index, g)); + } + + + template + typename graph_traits::vertices_size_type + max_wavefront(const Graph& g, VertexIndexMap index) + { + BOOST_USING_STD_MAX(); + typename graph_traits::vertices_size_type b = 0; + typename graph_traits::vertex_iterator i, end; + for (tie(i, end) = vertices(g); i != end; ++i) + b = max BOOST_PREVENT_MACRO_SUBSTITUTION(b, ith_wavefront(*i, g, index)); + return b; + } + + template + typename graph_traits::vertices_size_type + max_wavefront(const Graph& g) + { + return max_wavefront(g, get(vertex_index, g)); + } + + + template + double + aver_wavefront(const Graph& g, VertexIndexMap index) + { + double b = 0; + typename graph_traits::vertex_iterator i, end; + for (tie(i, end) = vertices(g); i != end; ++i) + b += ith_wavefront(*i, g, index); + + b /= num_vertices(g); + return b; + } + + template + double + aver_wavefront(const Graph& g) + { + return aver_wavefront(g, get(vertex_index, g)); + } + + + template + double + rms_wavefront(const Graph& g, VertexIndexMap index) + { + double b = 0; + typename graph_traits::vertex_iterator i, end; + for (tie(i, end) = vertices(g); i != end; ++i) + b += std::pow(double ( ith_wavefront(*i, g, index) ), 2.0); + + b /= num_vertices(g); + + return std::sqrt(b); + } + + template + double + rms_wavefront(const Graph& g) + { + return rms_wavefront(g, get(vertex_index, g)); + } + + +} // namespace boost + +#endif // BOOST_GRAPH_WAVEFRONT_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/counting_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/counting_iterator.hpp new file mode 100644 index 0000000000..1298a31f55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/counting_iterator.hpp @@ -0,0 +1,215 @@ +// Copyright David Abrahams 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) +#ifndef COUNTING_ITERATOR_DWA200348_HPP +# define COUNTING_ITERATOR_DWA200348_HPP + +# include +# include +# include +# include +# include +# include + +namespace boost { + +template < + class Incrementable + , class CategoryOrTraversal + , class Difference +> +class counting_iterator; + +namespace detail +{ + // Try to detect numeric types at compile time in ways compatible + // with the limitations of the compiler and library. + template + struct is_numeric_impl + { + // For a while, this wasn't true, but we rely on it below. This is a regression assert. + BOOST_STATIC_ASSERT(::boost::is_integral::value); + +# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + + BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits::is_specialized); + +# else + +# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) + BOOST_STATIC_CONSTANT( + bool, value = ( + boost::is_convertible::value + && boost::is_convertible::value + )); +# else + BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic::value); +# endif + +# endif + }; + + template + struct is_numeric + : mpl::bool_<(::boost::detail::is_numeric_impl::value)> + {}; + +# if defined(BOOST_HAS_LONG_LONG) + template <> + struct is_numeric< ::boost::long_long_type> + : mpl::true_ {}; + + template <> + struct is_numeric< ::boost::ulong_long_type> + : mpl::true_ {}; +# endif + + // Some compilers fail to have a numeric_limits specialization + template <> + struct is_numeric + : mpl::true_ {}; + + template + struct numeric_difference + { + typedef typename boost::detail::numeric_traits::difference_type type; + }; + + BOOST_STATIC_ASSERT(is_numeric::value); + + template + struct counting_iterator_base + { + typedef typename detail::ia_dflt_help< + CategoryOrTraversal + , mpl::eval_if< + is_numeric + , mpl::identity + , iterator_traversal + > + >::type traversal; + + typedef typename detail::ia_dflt_help< + Difference + , mpl::eval_if< + is_numeric + , numeric_difference + , iterator_difference + > + >::type difference; + + typedef iterator_adaptor< + counting_iterator // self + , Incrementable // Base + , Incrementable // Value +# ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY + const // MSVC won't strip this. Instead we enable Thomas' + // criterion (see boost/iterator/detail/facade_iterator_category.hpp) +# endif + , traversal + , Incrementable const& // reference + , difference + > type; + }; + + // Template class distance_policy_select -- choose a policy for computing the + // distance between counting_iterators at compile-time based on whether or not + // the iterator wraps an integer or an iterator, using "poor man's partial + // specialization". + + template struct distance_policy_select; + + // A policy for wrapped iterators + template + struct iterator_distance + { + static Difference distance(Incrementable1 x, Incrementable2 y) + { + return y - x; + } + }; + + // A policy for wrapped numbers + template + struct number_distance + { + static Difference distance(Incrementable1 x, Incrementable2 y) + { + return numeric_distance(x, y); + } + }; +} + +template < + class Incrementable + , class CategoryOrTraversal = use_default + , class Difference = use_default +> +class counting_iterator + : public detail::counting_iterator_base< + Incrementable, CategoryOrTraversal, Difference + >::type +{ + typedef typename detail::counting_iterator_base< + Incrementable, CategoryOrTraversal, Difference + >::type super_t; + + friend class iterator_core_access; + + public: + typedef typename super_t::difference_type difference_type; + + counting_iterator() { } + + counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {} + + counting_iterator(Incrementable x) + : super_t(x) + { + } + +# if 0 + template + counting_iterator( + counting_iterator const& t + , typename enable_if_convertible::type* = 0 + ) + : super_t(t.base()) + {} +# endif + + private: + + typename super_t::reference dereference() const + { + return this->base_reference(); + } + + template + difference_type + distance_to(counting_iterator const& y) const + { + typedef typename mpl::if_< + detail::is_numeric + , detail::number_distance + , detail::iterator_distance + >::type d; + + return d::distance(this->base(), y.base()); + } +}; + +// Manufacture a counting iterator for an arbitrary incrementable type +template +inline counting_iterator +make_counting_iterator(Incrementable x) +{ + typedef counting_iterator result_t; + return result_t(x); +} + + +} // namespace boost::iterator + +#endif // COUNTING_ITERATOR_DWA200348_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/detail/any_conversion_eater.hpp b/deal.II/contrib/boost/include/boost/iterator/detail/any_conversion_eater.hpp new file mode 100755 index 0000000000..25fa644889 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/detail/any_conversion_eater.hpp @@ -0,0 +1,19 @@ +// Copyright David Abrahams 2003. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef ANY_CONVERSION_EATER_DWA20031117_HPP +# define ANY_CONVERSION_EATER_DWA20031117_HPP + +namespace boost { namespace detail { + +// This type can be used in traits to "eat" up the one user-defined +// implicit conversion allowed. +struct any_conversion_eater +{ + template + any_conversion_eater(T const&); +}; + +}} // namespace boost::detail + +#endif // ANY_CONVERSION_EATER_DWA20031117_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/detail/config_def.hpp b/deal.II/contrib/boost/include/boost/iterator/detail/config_def.hpp new file mode 100644 index 0000000000..82b3b52cb3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/detail/config_def.hpp @@ -0,0 +1,140 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// no include guard multiple inclusion intended + +// +// This is a temporary workaround until the bulk of this is +// available in boost config. +// 23/02/03 thw +// + +#include // for prior +#include + +#ifdef BOOST_ITERATOR_CONFIG_DEF +# error you have nested config_def #inclusion. +#else +# define BOOST_ITERATOR_CONFIG_DEF +#endif + +// We enable this always now. Otherwise, the simple case in +// libs/iterator/test/constant_iterator_arrow.cpp fails to compile +// because the operator-> return is improperly deduced as a non-const +// pointer. +#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531)) + +// Recall that in general, compilers without partial specialization +// can't strip constness. Consider counting_iterator, which normally +// passes a const Value to iterator_facade. As a result, any code +// which makes a std::vector of the iterator's value_type will fail +// when its allocator declares functions overloaded on reference and +// const_reference (the same type). +// +// Furthermore, Borland 5.5.1 drops constness in enough ways that we +// end up using a proxy for operator[] when we otherwise shouldn't. +// Using reference constness gives it an extra hint that it can +// return the value_type from operator[] directly, but is not +// strictly necessary. Not sure how best to resolve this one. + +# define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1 + +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531)) \ + || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ + || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) +# define BOOST_NO_LVALUE_RETURN_DETECTION + +# if 0 // test code + struct v {}; + + typedef char (&no)[3]; + + template + no foo(T const&, ...); + + template + char foo(T&, int); + + + struct value_iterator + { + v operator*() const; + }; + + template + struct lvalue_deref_helper + { + static T& x; + enum { value = (sizeof(foo(*x,0)) == 1) }; + }; + + int z2[(lvalue_deref_helper::value == 1) ? 1 : -1]; + int z[(lvalue_deref_helper::value) == 1 ? -1 : 1 ]; +# endif + +#endif + +#if BOOST_WORKAROUND(__MWERKS__, <=0x2407) +# define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types" +#endif + +#if BOOST_WORKAROUND(__GNUC__, == 2) \ + || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) +# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile: + +# if 0 // test code + #include + template + struct foo + { + foo(T); + + template + foo(foo const& other) : p(other.p) { } + + T p; + }; + + bool x = boost::is_convertible, foo >::value; +# endif + +#endif + +#if BOOST_WORKAROUND(__GNUC__, == 2 && __GNUC_MINOR__ == 95) \ + || BOOST_WORKAROUND(__MWERKS__, <= 0x2407) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) +# define BOOST_ITERATOR_NO_MPL_AUX_HAS_XXX // "MPL's has_xxx facility doesn't work" +#endif + +#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE)) +# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY +#endif + +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_ARG_DEPENDENT_TYPENAME typename +# else +# define BOOST_ARG_DEPENDENT_TYPENAME +# endif + +# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + +// GCC-2.95 eagerly instantiates templated constructors and conversion +// operators in convertibility checks, causing premature errors. +// +// Borland's problems are harder to diagnose due to lack of an +// instantiation stack backtrace. They may be due in part to the fact +// that it drops cv-qualification willy-nilly in templates. +# define BOOST_NO_ONE_WAY_ITERATOR_INTEROP +# endif + +// no include guard; multiple inclusion intended diff --git a/deal.II/contrib/boost/include/boost/iterator/detail/config_undef.hpp b/deal.II/contrib/boost/include/boost/iterator/detail/config_undef.hpp new file mode 100644 index 0000000000..9dcd1d525f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/detail/config_undef.hpp @@ -0,0 +1,25 @@ +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// no include guard multiple inclusion intended + +// +// This is a temporary workaround until the bulk of this is +// available in boost config. +// 23/02/03 thw +// + +#undef BOOST_NO_IS_CONVERTIBLE +#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE +#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY +#undef BOOST_ARG_DEPENDENT_TYPENAME +#undef BOOST_NO_LVALUE_RETURN_DETECTION +#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP + +#ifdef BOOST_ITERATOR_CONFIG_DEF +# undef BOOST_ITERATOR_CONFIG_DEF +#else +# error missing or nested #include config_def +#endif diff --git a/deal.II/contrib/boost/include/boost/iterator/detail/enable_if.hpp b/deal.II/contrib/boost/include/boost/iterator/detail/enable_if.hpp new file mode 100644 index 0000000000..45428a5bb2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/detail/enable_if.hpp @@ -0,0 +1,86 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_ENABLE_IF_23022003THW_HPP +#define BOOST_ENABLE_IF_23022003THW_HPP + +#include +#include + +#include + +// +// Boost iterators uses its own enable_if cause we need +// special semantics for deficient compilers. +// 23/02/03 thw +// + +namespace boost +{ + + namespace iterators + { + // + // Base machinery for all kinds of enable if + // + template + struct enabled + { + template + struct base + { + typedef T type; + }; + }; + + // + // For compilers that don't support "Substitution Failure Is Not An Error" + // enable_if falls back to always enabled. See comments + // on operator implementation for consequences. + // + template<> + struct enabled + { + template + struct base + { +#ifdef BOOST_NO_SFINAE + + typedef T type; + + // This way to do it would give a nice error message containing + // invalid overload, but has the big disadvantage that + // there is no reference to user code in the error message. + // + // struct invalid_overload; + // typedef invalid_overload type; + // +#endif + }; + }; + + + template + struct enable_if +# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE) + : enabled<(Cond::value)>::template base +# else + : mpl::identity +# endif + { +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + typedef Return type; +# endif + }; + + } // namespace iterators + +} // namespace boost + +#include + +#endif // BOOST_ENABLE_IF_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/detail/facade_iterator_category.hpp b/deal.II/contrib/boost/include/boost/iterator/detail/facade_iterator_category.hpp new file mode 100755 index 0000000000..67287007b5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/detail/facade_iterator_category.hpp @@ -0,0 +1,209 @@ +// Copyright David Abrahams 2003. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP +# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP + +# include + +# include + +# include // used in iterator_tag inheritance logic +# include +# include +# include +# include + +# include +# include +# include +# include + +# include + +# include // try to keep this last + +# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY +# include +# endif + +// +// iterator_category deduction for iterator_facade +// + +// forward declaration +namespace boost { struct use_default; } + +namespace boost { namespace detail { + +struct input_output_iterator_tag + : std::input_iterator_tag +{ + // Using inheritance for only input_iterator_tag helps to avoid + // ambiguities when a stdlib implementation dispatches on a + // function which is overloaded on both input_iterator_tag and + // output_iterator_tag, as STLPort does, in its __valid_range + // function. I claim it's better to avoid the ambiguity in these + // cases. + operator std::output_iterator_tag() const + { + return std::output_iterator_tag(); + } +}; + +// +// True iff the user has explicitly disabled writability of this +// iterator. Pass the iterator_facade's Value parameter and its +// nested ::reference type. +// +template +struct iterator_writability_disabled +# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic? + : mpl::or_< + is_const + , boost::detail::indirect_traits::is_reference_to_const + , is_const + > +# else + : is_const +# endif +{}; + + +// +// Convert an iterator_facade's traversal category, Value parameter, +// and ::reference type to an appropriate old-style category. +// +// If writability has been disabled per the above metafunction, the +// result will not be convertible to output_iterator_tag. +// +// Otherwise, if Traversal == single_pass_traversal_tag, the following +// conditions will result in a tag that is convertible both to +// input_iterator_tag and output_iterator_tag: +// +// 1. Reference is a reference to non-const +// 2. Reference is not a reference and is convertible to Value +// +template +struct iterator_facade_default_category + : mpl::eval_if< + mpl::and_< + is_reference + , is_convertible + > + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::if_< + is_convertible + , std::bidirectional_iterator_tag + , std::forward_iterator_tag + > + > + , typename mpl::eval_if< + mpl::and_< + is_convertible + + // check for readability + , is_convertible + > + , mpl::identity + , mpl::identity + > + > +{ +}; + +// True iff T is convertible to an old-style iterator category. +template +struct is_iterator_category + : mpl::or_< + is_convertible + , is_convertible + > +{ +}; + +template +struct is_iterator_traversal + : is_convertible +{}; + +// +// A composite iterator_category tag convertible to Category (a pure +// old-style category) and Traversal (a pure traversal tag). +// Traversal must be a strict increase of the traversal power given by +// Category. +// +template +struct iterator_category_with_traversal + : Category, Traversal +{ +# if 0 + // Because of limitations on multiple user-defined conversions, + // this should be a good test of whether convertibility is enough + // in the spec, or whether we need to specify inheritance. + operator Category() const { return Category(); } + operator Traversal() const { return Traversal(); } +# endif + +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + // Make sure this isn't used to build any categories where + // convertibility to Traversal is redundant. Should just use the + // Category element in that case. + BOOST_STATIC_ASSERT( + !(is_convertible< + typename iterator_category_to_traversal::type + , Traversal + >::value)); + + BOOST_STATIC_ASSERT(is_iterator_category::value); + BOOST_STATIC_ASSERT(!is_iterator_category::value); + BOOST_STATIC_ASSERT(!is_iterator_traversal::value); +# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) + BOOST_STATIC_ASSERT(is_iterator_traversal::value); +# endif +# endif +}; + +// Computes an iterator_category tag whose traversal is Traversal and +// which is appropriate for an iterator +template +struct facade_iterator_category_impl +{ +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + BOOST_STATIC_ASSERT(!is_iterator_category::value); +# endif + + typedef typename iterator_facade_default_category< + Traversal,ValueParam,Reference + >::type category; + + typedef typename mpl::if_< + is_same< + Traversal + , typename iterator_category_to_traversal::type + > + , category + , iterator_category_with_traversal + >::type type; +}; + +// +// Compute an iterator_category for iterator_facade +// +template +struct facade_iterator_category + : mpl::eval_if< + is_iterator_category + , mpl::identity // old-style categories are fine as-is + , facade_iterator_category_impl + > +{ +}; + +}} // namespace boost::detail + +# include + +#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/detail/minimum_category.hpp b/deal.II/contrib/boost/include/boost/iterator/detail/minimum_category.hpp new file mode 100755 index 0000000000..74cef63f35 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/detail/minimum_category.hpp @@ -0,0 +1,116 @@ +// Copyright David Abrahams 2003. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef MINIMUM_CATEGORY_DWA20031119_HPP +# define MINIMUM_CATEGORY_DWA20031119_HPP + +# include +# include + +# include + +namespace boost { namespace detail { +// +// Returns the minimum category type or error_type +// if T1 and T2 are unrelated. +// +// For compilers not supporting is_convertible this only +// works with the new boost return and traversal category +// types. The exact boost _types_ are required. No derived types +// will work. +// +// +template +struct minimum_category_impl +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) +{ + template struct apply + { + typedef T2 type; + }; + typedef void type; +} +# endif +; + +template +struct error_not_related_by_convertibility; + +template <> +struct minimum_category_impl +{ + template struct apply + { + typedef T2 type; + }; +}; + +template <> +struct minimum_category_impl +{ + template struct apply + { + typedef T1 type; + }; +}; + +template <> +struct minimum_category_impl +{ + template struct apply + { + BOOST_STATIC_ASSERT((is_same::value)); + typedef T1 type; + }; +}; + +template <> +struct minimum_category_impl +{ + template struct apply + : error_not_related_by_convertibility + { + }; +}; + +template +struct minimum_category +{ + typedef minimum_category_impl< +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround + is_same::value || +# endif + ::boost::is_convertible::value + , ::boost::is_convertible::value +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround + || is_same::value +# endif + > outer; + + typedef typename outer::template apply inner; + typedef typename inner::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2)) +}; + +template <> +struct minimum_category +{ + template + struct apply : minimum_category + {}; + + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2)) +}; + +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround +template <> +struct minimum_category +{ + typedef int type; +}; +# endif + +}} // namespace boost::detail + +#endif // MINIMUM_CATEGORY_DWA20031119_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/filter_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/filter_iterator.hpp new file mode 100644 index 0000000000..96fb84359f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/filter_iterator.hpp @@ -0,0 +1,135 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP +#define BOOST_FILTER_ITERATOR_23022003THW_HPP + +#include +#include +#include + +#include +#include + +namespace boost +{ + template + class filter_iterator; + + namespace detail + { + template + struct filter_iterator_base + { + typedef iterator_adaptor< + filter_iterator + , Iterator + , use_default + , typename mpl::if_< + is_convertible< + typename iterator_traversal::type + , random_access_traversal_tag + > + , bidirectional_traversal_tag + , use_default + >::type + > type; + }; + } + + template + class filter_iterator + : public detail::filter_iterator_base::type + { + typedef typename detail::filter_iterator_base< + Predicate, Iterator + >::type super_t; + + friend class iterator_core_access; + + public: + filter_iterator() { } + + filter_iterator(Predicate f, Iterator x, Iterator end = Iterator()) + : super_t(x), m_predicate(f), m_end(end) + { + satisfy_predicate(); + } + + filter_iterator(Iterator x, Iterator end = Iterator()) + : super_t(x), m_predicate(), m_end(end) + { + // Pro8 is a little too aggressive about instantiating the + // body of this function. +#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) + // Don't allow use of this constructor if Predicate is a + // function pointer type, since it will be 0. + BOOST_STATIC_ASSERT(is_class::value); +#endif + satisfy_predicate(); + } + + template + filter_iterator( + filter_iterator const& t + , typename enable_if_convertible::type* = 0 + ) + : super_t(t.base()), m_predicate(t.predicate()), m_end(t.end()) {} + + Predicate predicate() const { return m_predicate; } + + Iterator end() const { return m_end; } + + private: + void increment() + { + ++(this->base_reference()); + satisfy_predicate(); + } + + void decrement() + { + while(!this->m_predicate(*--(this->base_reference()))){}; + } + + void satisfy_predicate() + { + while (this->base() != this->m_end && !this->m_predicate(*this->base())) + ++(this->base_reference()); + } + + // Probably should be the initial base class so it can be + // optimized away via EBO if it is an empty class. + Predicate m_predicate; + Iterator m_end; + }; + + template + filter_iterator + make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator()) + { + return filter_iterator(f,x,end); + } + + template + filter_iterator + make_filter_iterator( + typename iterators::enable_if< + is_class + , Iterator + >::type x + , Iterator end = Iterator() +#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) + , Predicate* = 0 +#endif + ) + { + return filter_iterator(x,end); + } + +} // namespace boost + +#endif // BOOST_FILTER_ITERATOR_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/indirect_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/indirect_iterator.hpp new file mode 100644 index 0000000000..f181107121 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/indirect_iterator.hpp @@ -0,0 +1,139 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_INDIRECT_ITERATOR_23022003THW_HPP +#define BOOST_INDIRECT_ITERATOR_23022003THW_HPP + +#include +#include + +#include +#include +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include + +#ifdef BOOST_MPL_CFG_NO_HAS_XXX +# include +# include +# include +# include +#endif + +#include // must be last #include + +namespace boost +{ + template + class indirect_iterator; + + namespace detail + { + template + struct indirect_base + { + typedef typename iterator_traits::value_type dereferenceable; + + typedef iterator_adaptor< + indirect_iterator + , Iter + , typename ia_dflt_help< + Value, pointee + >::type + , Category + , typename ia_dflt_help< + Reference + , mpl::eval_if< + is_same + , indirect_reference + , add_reference + > + >::type + , Difference + > type; + }; + + template <> + struct indirect_base {}; + } // namespace detail + + + template < + class Iterator + , class Value = use_default + , class Category = use_default + , class Reference = use_default + , class Difference = use_default + > + class indirect_iterator + : public detail::indirect_base< + Iterator, Value, Category, Reference, Difference + >::type + { + typedef typename detail::indirect_base< + Iterator, Value, Category, Reference, Difference + >::type super_t; + + friend class iterator_core_access; + + public: + indirect_iterator() {} + + indirect_iterator(Iterator iter) + : super_t(iter) {} + + template < + class Iterator2, class Value2, class Category2 + , class Reference2, class Difference2 + > + indirect_iterator( + indirect_iterator< + Iterator2, Value2, Category2, Reference2, Difference2 + > const& y + , typename enable_if_convertible::type* = 0 + ) + : super_t(y.base()) + {} + + private: + typename super_t::reference dereference() const + { +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) + return const_cast(**this->base()); +# else + return **this->base(); +# endif + } + }; + + template + inline + indirect_iterator make_indirect_iterator(Iter x) + { + return indirect_iterator(x); + } + + template + inline + indirect_iterator make_indirect_iterator(Iter x, Traits* = 0) + { + return indirect_iterator(x); + } + +} // namespace boost + +#include + +#endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/interoperable.hpp b/deal.II/contrib/boost/include/boost/iterator/interoperable.hpp new file mode 100644 index 0000000000..c13dd9b47b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/interoperable.hpp @@ -0,0 +1,50 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_INTEROPERABLE_23022003THW_HPP +# define BOOST_INTEROPERABLE_23022003THW_HPP + +# include +# include + +# include + +# include // must appear last + +namespace boost +{ + + // + // Meta function that determines whether two + // iterator types are considered interoperable. + // + // Two iterator types A,B are considered interoperable if either + // A is convertible to B or vice versa. + // This interoperability definition is in sync with the + // standards requirements on constant/mutable container + // iterators (23.1 [lib.container.requirements]). + // + // For compilers that don't support is_convertible + // is_interoperable gives false positives. See comments + // on operator implementation for consequences. + // + template + struct is_interoperable +# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY + : mpl::true_ +# else + : mpl::or_< + is_convertible< A, B > + , is_convertible< B, A > > +# endif + { + }; + +} // namespace boost + +# include + +#endif // BOOST_INTEROPERABLE_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/is_lvalue_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/is_lvalue_iterator.hpp new file mode 100755 index 0000000000..3beb90df6d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/is_lvalue_iterator.hpp @@ -0,0 +1,150 @@ +// Copyright David Abrahams 2003. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP +# define IS_LVALUE_ITERATOR_DWA2003112_HPP + +#include + +#include +#include + +#include + +// should be the last #includes +#include +#include + +#ifndef BOOST_NO_IS_CONVERTIBLE + +namespace boost { + +namespace detail +{ +#ifndef BOOST_NO_LVALUE_RETURN_DETECTION + // Calling lvalue_preserver( , 0 ) returns a reference + // to the expression's result if is an lvalue, or + // not_an_lvalue() otherwise. + struct not_an_lvalue {}; + + template + T& lvalue_preserver(T&, int); + + template + not_an_lvalue lvalue_preserver(U const&, ...); + +# define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0) + +#else + +# define BOOST_LVALUE_PRESERVER(expr) expr + +#endif + + // Guts of is_lvalue_iterator. Value is the iterator's value_type + // and the result is computed in the nested rebind template. + template + struct is_lvalue_iterator_impl + { + // Eat implicit conversions so we don't report true for things + // convertible to Value const& + struct conversion_eater + { + conversion_eater(Value&); + }; + + static char tester(conversion_eater, int); + static char (& tester(any_conversion_eater, ...) )[2]; + + template + struct rebind + { + static It& x; + + BOOST_STATIC_CONSTANT( + bool + , value = ( + sizeof( + is_lvalue_iterator_impl::tester( + BOOST_LVALUE_PRESERVER(*x), 0 + ) + ) == 1 + ) + ); + }; + }; + +#undef BOOST_LVALUE_PRESERVER + + // + // void specializations to handle std input and output iterators + // + template <> + struct is_lvalue_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS + template <> + struct is_lvalue_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; + + template <> + struct is_lvalue_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; + + template <> + struct is_lvalue_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; +#endif + + // + // This level of dispatching is required for Borland. We might save + // an instantiation by removing it for others. + // + template + struct is_readable_lvalue_iterator_impl + : is_lvalue_iterator_impl< + BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type const + >::template rebind + {}; + + template + struct is_non_const_lvalue_iterator_impl + : is_lvalue_iterator_impl< + BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type + >::template rebind + {}; +} // namespace detail + +// Define the trait with full mpl lambda capability and various broken +// compiler workarounds +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_lvalue_iterator,T,::boost::detail::is_readable_lvalue_iterator_impl::value) + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl::value) + +} // namespace boost + +#endif + +#include +#include + +#endif // IS_LVALUE_ITERATOR_DWA2003112_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/is_readable_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/is_readable_iterator.hpp new file mode 100755 index 0000000000..60d6ff07f5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/is_readable_iterator.hpp @@ -0,0 +1,108 @@ +// Copyright David Abrahams 2003. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef IS_READABLE_ITERATOR_DWA2003112_HPP +# define IS_READABLE_ITERATOR_DWA2003112_HPP + +#include +#include + +#include +#include + +// should be the last #include +#include + +#ifndef BOOST_NO_IS_CONVERTIBLE + +namespace boost { + +namespace detail +{ + // Guts of is_readable_iterator. Value is the iterator's value_type + // and the result is computed in the nested rebind template. + template + struct is_readable_iterator_impl + { + static char tester(Value&, int); + static char (& tester(any_conversion_eater, ...) )[2]; + + template + struct rebind + { + static It& x; + + BOOST_STATIC_CONSTANT( + bool + , value = ( + sizeof( + is_readable_iterator_impl::tester(*x, 1) + ) == 1 + ) + ); + }; + }; + +#undef BOOST_READABLE_PRESERVER + + // + // void specializations to handle std input and output iterators + // + template <> + struct is_readable_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS + template <> + struct is_readable_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; + + template <> + struct is_readable_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; + + template <> + struct is_readable_iterator_impl + { + template + struct rebind : boost::mpl::false_ + {}; + }; +#endif + + // + // This level of dispatching is required for Borland. We might save + // an instantiation by removing it for others. + // + template + struct is_readable_iterator_impl2 + : is_readable_iterator_impl< + BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type const + >::template rebind + {}; +} // namespace detail + +// Define the trait with full mpl lambda capability and various broken +// compiler workarounds +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_readable_iterator,T,::boost::detail::is_readable_iterator_impl2::value) + +} // namespace boost + +#endif + +#include + +#endif // IS_READABLE_ITERATOR_DWA2003112_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/iterator_adaptor.hpp b/deal.II/contrib/boost/include/boost/iterator/iterator_adaptor.hpp new file mode 100644 index 0000000000..457c439659 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/iterator_adaptor.hpp @@ -0,0 +1,366 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP +#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include +#include + +#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY +# include +#else +# include +#endif + +#include + +#include + +namespace boost +{ + // Used as a default template argument internally, merely to + // indicate "use the default", this can also be passed by users + // explicitly in order to specify that the default should be used. + struct use_default; + +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + // the incompleteness of use_default causes massive problems for + // is_convertible (naturally). This workaround is fortunately not + // needed for vc6/vc7. + template + struct is_convertible + : mpl::false_ {}; +# endif + + namespace detail + { + + // + // Result type used in enable_if_convertible meta function. + // This can be an incomplete type, as only pointers to + // enable_if_convertible< ... >::type are used. + // We could have used void for this, but conversion to + // void* is just to easy. + // + struct enable_type; + } + + + // + // enable_if for use in adapted iterators constructors. + // + // In order to provide interoperability between adapted constant and + // mutable iterators, adapted iterators will usually provide templated + // conversion constructors of the following form + // + // template + // class adapted_iterator : + // public iterator_adaptor< adapted_iterator, Iterator > + // { + // public: + // + // ... + // + // template + // adapted_iterator( + // OtherIterator const& it + // , typename enable_if_convertible::type* = 0); + // + // ... + // }; + // + // enable_if_convertible is used to remove those overloads from the overload + // set that cannot be instantiated. For all practical purposes only overloads + // for constant/mutable interaction will remain. This has the advantage that + // meta functions like boost::is_convertible do not return false positives, + // as they can only look at the signature of the conversion constructor + // and not at the actual instantiation. + // + // enable_if_interoperable can be safely used in user code. It falls back to + // always enabled for compilers that don't support enable_if or is_convertible. + // There is no need for compiler specific workarounds in user code. + // + // The operators implementation relies on boost::is_convertible not returning + // false positives for user/library defined iterator types. See comments + // on operator implementation for consequences. + // +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + template + struct enable_if_convertible + { + typedef typename mpl::if_< + mpl::or_< + is_same + , is_convertible + > + , detail::enable_type + , int& + >::type type; + }; + +# elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE) + + template + struct enable_if_convertible + { + typedef detail::enable_type type; + }; + +# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300 + + // For some reason vc7.1 needs us to "cut off" instantiation + // of is_convertible in a few cases. + template + struct enable_if_convertible + : iterators::enable_if< + mpl::or_< + is_same + , is_convertible + > + , detail::enable_type + > + {}; + +# else + + template + struct enable_if_convertible + : iterators::enable_if< + is_convertible + , detail::enable_type + > + {}; + +# endif + + // + // Default template argument handling for iterator_adaptor + // + namespace detail + { + // If T is use_default, return the result of invoking + // DefaultNullaryFn, otherwise return T. + template + struct ia_dflt_help + : mpl::eval_if< + is_same + , DefaultNullaryFn + , mpl::identity + > + { + }; + + // A metafunction which computes an iterator_adaptor's base class, + // a specialization of iterator_facade. + template < + class Derived + , class Base + , class Value + , class Traversal + , class Reference + , class Difference + > + struct iterator_adaptor_base + { + typedef iterator_facade< + Derived + +# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY + , typename detail::ia_dflt_help< + Value + , mpl::eval_if< + is_same + , iterator_value + , remove_reference + > + >::type +# else + , typename detail::ia_dflt_help< + Value, iterator_value + >::type +# endif + + , typename detail::ia_dflt_help< + Traversal + , iterator_traversal + >::type + + , typename detail::ia_dflt_help< + Reference + , mpl::eval_if< + is_same + , iterator_reference + , add_reference + > + >::type + + , typename detail::ia_dflt_help< + Difference, iterator_difference + >::type + > + type; + }; + + // workaround for aC++ CR JAGaf33512 + template + inline void iterator_adaptor_assert_traversal () + { + BOOST_STATIC_ASSERT((is_convertible::value)); + } + } + + // + // Iterator Adaptor + // + // The parameter ordering changed slightly with respect to former + // versions of iterator_adaptor The idea is that when the user needs + // to fiddle with the reference type it is highly likely that the + // iterator category has to be adjusted as well. Any of the + // following four template arguments may be ommitted or explicitly + // replaced by use_default. + // + // Value - if supplied, the value_type of the resulting iterator, unless + // const. If const, a conforming compiler strips constness for the + // value_type. If not supplied, iterator_traits::value_type is used + // + // Category - the traversal category of the resulting iterator. If not + // supplied, iterator_traversal::type is used. + // + // Reference - the reference type of the resulting iterator, and in + // particular, the result type of operator*(). If not supplied but + // Value is supplied, Value& is used. Otherwise + // iterator_traits::reference is used. + // + // Difference - the difference_type of the resulting iterator. If not + // supplied, iterator_traits::difference_type is used. + // + template < + class Derived + , class Base + , class Value = use_default + , class Traversal = use_default + , class Reference = use_default + , class Difference = use_default + > + class iterator_adaptor + : public detail::iterator_adaptor_base< + Derived, Base, Value, Traversal, Reference, Difference + >::type + { + friend class iterator_core_access; + + protected: + typedef typename detail::iterator_adaptor_base< + Derived, Base, Value, Traversal, Reference, Difference + >::type super_t; + public: + iterator_adaptor() {} + + explicit iterator_adaptor(Base const &iter) + : m_iterator(iter) + { + } + + typedef Base base_type; + + Base const& base() const + { return m_iterator; } + + protected: + // for convenience in derived classes + typedef iterator_adaptor iterator_adaptor_; + + // + // lvalue access to the Base object for Derived + // + Base const& base_reference() const + { return m_iterator; } + + Base& base_reference() + { return m_iterator; } + + private: + // + // Core iterator interface for iterator_facade. This is private + // to prevent temptation for Derived classes to use it, which + // will often result in an error. Derived classes should use + // base_reference(), above, to get direct access to m_iterator. + // + typename super_t::reference dereference() const + { return *m_iterator; } + + template < + class OtherDerived, class OtherIterator, class V, class C, class R, class D + > + bool equal(iterator_adaptor const& x) const + { + // Maybe readd with same_distance + // BOOST_STATIC_ASSERT( + // (detail::same_category_and_difference::value) + // ); + return m_iterator == x.base(); + } + + typedef typename iterator_category_to_traversal< + typename super_t::iterator_category + >::type my_traversal; + +# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \ + detail::iterator_adaptor_assert_traversal(); + + void advance(typename super_t::difference_type n) + { + BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) + m_iterator += n; + } + + void increment() { ++m_iterator; } + + void decrement() + { + BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag) + --m_iterator; + } + + template < + class OtherDerived, class OtherIterator, class V, class C, class R, class D + > + typename super_t::difference_type distance_to( + iterator_adaptor const& y) const + { + BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) + // Maybe readd with same_distance + // BOOST_STATIC_ASSERT( + // (detail::same_category_and_difference::value) + // ); + return y.base() - m_iterator; + } + +# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL + + private: // data members + Base m_iterator; + }; + +} // namespace boost + +#include + +#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/iterator_archetypes.hpp b/deal.II/contrib/boost/include/boost/iterator/iterator_archetypes.hpp new file mode 100644 index 0000000000..9ffa4200dc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/iterator_archetypes.hpp @@ -0,0 +1,514 @@ +// (C) Copyright Jeremy Siek 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_ITERATOR_ARCHETYPES_HPP +#define BOOST_ITERATOR_ARCHETYPES_HPP + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { + +template +struct access_archetype; + +template +struct traversal_archetype; + +namespace iterator_archetypes +{ + enum { + readable_iterator_bit = 1 + , writable_iterator_bit = 2 + , swappable_iterator_bit = 4 + , lvalue_iterator_bit = 8 + }; + + // Not quite tags, since dispatching wouldn't work. + typedef mpl::int_::type readable_iterator_t; + typedef mpl::int_::type writable_iterator_t; + + typedef mpl::int_< + (readable_iterator_bit|writable_iterator_bit) + >::type readable_writable_iterator_t; + + typedef mpl::int_< + (readable_iterator_bit|lvalue_iterator_bit) + >::type readable_lvalue_iterator_t; + + typedef mpl::int_< + (lvalue_iterator_bit|writable_iterator_bit) + >::type writable_lvalue_iterator_t; + + typedef mpl::int_::type swappable_iterator_t; + typedef mpl::int_::type lvalue_iterator_t; + + template + struct has_access + : mpl::equal_to< + mpl::bitand_ + , Base + > + {}; +} + +namespace detail +{ + template + struct assign_proxy + { + assign_proxy& operator=(T) { return *this; } + }; + + template + struct read_proxy + { + operator T() { return static_object::get(); } + }; + + template + struct read_write_proxy + : read_proxy // Use to inherit from assign_proxy, but that doesn't work. -JGS + { + read_write_proxy& operator=(T) { return *this; } + }; + + template + struct arrow_proxy + { + T const* operator->() const { return 0; } + }; + + struct no_operator_brackets {}; + + template + struct readable_operator_brackets + { + read_proxy operator[](std::ptrdiff_t n) const { return read_proxy(); } + }; + + template + struct writable_operator_brackets + { + read_write_proxy operator[](std::ptrdiff_t n) const { return read_write_proxy(); } + }; + + template + struct operator_brackets + : mpl::aux::msvc_eti_base< + typename mpl::eval_if< + is_convertible + , mpl::eval_if< + iterator_archetypes::has_access< + AccessCategory + , iterator_archetypes::writable_iterator_t + > + , mpl::identity > + , mpl::if_< + iterator_archetypes::has_access< + AccessCategory + , iterator_archetypes::readable_iterator_t + > + , readable_operator_brackets + , no_operator_brackets + > + > + , mpl::identity + >::type + >::type + {}; + + template + struct traversal_archetype_impl + { + template struct archetype; + }; + + // Constructor argument for those iterators that + // are not default constructible + struct ctor_arg {}; + + template + struct traversal_archetype_ + : mpl::aux::msvc_eti_base< + typename traversal_archetype_impl::template archetype + >::type + { + typedef typename + traversal_archetype_impl::template archetype + base; + + traversal_archetype_() {} + + traversal_archetype_(ctor_arg arg) + : base(arg) + {} + }; + + template <> + struct traversal_archetype_impl + { + template + struct archetype + { + explicit archetype(ctor_arg) {} + + struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS + typedef bogus difference_type; + + Derived& operator++() { return (Derived&)static_object::get(); } + Derived operator++(int) const { return (Derived&)static_object::get(); } + }; + }; + + template <> + struct traversal_archetype_impl + { + template + struct archetype + : public equality_comparable< traversal_archetype_ >, + public traversal_archetype_ + { + explicit archetype(ctor_arg arg) + : traversal_archetype_(arg) + {} + }; + }; + + template + bool operator==(traversal_archetype_ const&, + traversal_archetype_ const&) { return true; } + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + // doesn't seem to pick up != from equality_comparable + template + bool operator!=(traversal_archetype_ const&, + traversal_archetype_ const&) { return true; } +#endif + template <> + struct traversal_archetype_impl + { + template + struct archetype + : public traversal_archetype_ + { + archetype() + : traversal_archetype_(ctor_arg()) + {} + typedef std::ptrdiff_t difference_type; + }; + }; + + template <> + struct traversal_archetype_impl + { + template + struct archetype + : public traversal_archetype_ + { + Derived& operator--() { return static_object::get(); } + Derived operator--(int) const { return static_object::get(); } + }; + }; + + template <> + struct traversal_archetype_impl + { + template + struct archetype + : public traversal_archetype_ + { + Derived& operator+=(std::ptrdiff_t) { return static_object::get(); } + Derived& operator-=(std::ptrdiff_t) { return static_object::get(); } + }; + }; + + template + Derived& operator+(traversal_archetype_ const&, + std::ptrdiff_t) { return static_object::get(); } + + template + Derived& operator+(std::ptrdiff_t, + traversal_archetype_ const&) + { return static_object::get(); } + + template + Derived& operator-(traversal_archetype_ const&, + std::ptrdiff_t) + { return static_object::get(); } + + template + std::ptrdiff_t operator-(traversal_archetype_ const&, + traversal_archetype_ const&) + { return 0; } + + template + bool operator<(traversal_archetype_ const&, + traversal_archetype_ const&) + { return true; } + + template + bool operator>(traversal_archetype_ const&, + traversal_archetype_ const&) + { return true; } + + template + bool operator<=(traversal_archetype_ const&, + traversal_archetype_ const&) + { return true; } + + template + bool operator>=(traversal_archetype_ const&, + traversal_archetype_ const&) + { return true; } + + struct bogus_type; + + template + struct convertible_type + : mpl::if_< is_const, + typename remove_const::type, + bogus_type > + {}; + +} // namespace detail + + +template struct undefined; + +template +struct iterator_access_archetype_impl +{ + template struct archetype; +}; + +template +struct iterator_access_archetype + : mpl::aux::msvc_eti_base< + typename iterator_access_archetype_impl< + AccessCategory + >::template archetype + >::type +{ +}; + +template <> +struct iterator_access_archetype_impl< + iterator_archetypes::readable_iterator_t +> +{ + template + struct archetype + { + typedef typename remove_cv::type value_type; + typedef Value reference; + typedef Value* pointer; + + value_type operator*() const { return static_object::get(); } + + detail::arrow_proxy operator->() const { return detail::arrow_proxy(); } + }; +}; + +template <> +struct iterator_access_archetype_impl< + iterator_archetypes::writable_iterator_t +> +{ + template + struct archetype + { +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + BOOST_STATIC_ASSERT(!is_const::value); +# endif + typedef void value_type; + typedef void reference; + typedef void pointer; + + detail::assign_proxy operator*() const { return detail::assign_proxy(); } + }; +}; + +template <> +struct iterator_access_archetype_impl< + iterator_archetypes::readable_writable_iterator_t +> +{ + template + struct archetype + : public virtual iterator_access_archetype< + Value, iterator_archetypes::readable_iterator_t + > + { + typedef detail::read_write_proxy reference; + + detail::read_write_proxy operator*() const { return detail::read_write_proxy(); } + }; +}; + +template <> +struct iterator_access_archetype_impl +{ + template + struct archetype + : public virtual iterator_access_archetype< + Value, iterator_archetypes::readable_iterator_t + > + { + typedef Value& reference; + + Value& operator*() const { return static_object::get(); } + Value* operator->() const { return 0; } + }; +}; + +template <> +struct iterator_access_archetype_impl +{ + template + struct archetype + : public virtual iterator_access_archetype< + Value, iterator_archetypes::readable_lvalue_iterator_t + > + { +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + BOOST_STATIC_ASSERT((!is_const::value)); +# endif + }; +}; + + +template +struct iterator_archetype; + +template +struct traversal_archetype_base + : detail::operator_brackets< + typename remove_cv::type + , AccessCategory + , TraversalCategory + > + , detail::traversal_archetype_< + iterator_archetype + , Value + , TraversalCategory + > +{ +}; + +namespace detail +{ + template + struct iterator_archetype_base + : iterator_access_archetype + , traversal_archetype_base + { + typedef iterator_access_archetype access; + + typedef typename detail::facade_iterator_category< + TraversalCategory + , typename mpl::eval_if< + iterator_archetypes::has_access< + AccessCategory, iterator_archetypes::writable_iterator_t + > + , remove_const + , add_const + >::type + , typename access::reference + >::type iterator_category; + + // Needed for some broken libraries (see below) + typedef boost::iterator< + iterator_category + , Value + , typename traversal_archetype_base< + Value, AccessCategory, TraversalCategory + >::difference_type + , typename access::pointer + , typename access::reference + > workaround_iterator_base; + }; +} + +template +struct iterator_archetype + : public detail::iterator_archetype_base + + // These broken libraries require derivation from std::iterator + // (or related magic) in order to handle iter_swap and other + // iterator operations +# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \ + || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101)) + , public detail::iterator_archetype_base< + Value, AccessCategory, TraversalCategory + >::workaround_iterator_base +# endif +{ + // Derivation from std::iterator above caused references to nested + // types to be ambiguous, so now we have to redeclare them all + // here. +# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \ + || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101)) + + typedef detail::iterator_archetype_base< + Value,AccessCategory,TraversalCategory + > base; + + typedef typename base::value_type value_type; + typedef typename base::reference reference; + typedef typename base::pointer pointer; + typedef typename base::difference_type difference_type; + typedef typename base::iterator_category iterator_category; +# endif + + iterator_archetype() { } + iterator_archetype(iterator_archetype const& x) + : detail::iterator_archetype_base< + Value + , AccessCategory + , TraversalCategory + >(x) + {} + + iterator_archetype& operator=(iterator_archetype const&) + { return *this; } + +# if 0 + // Optional conversion from mutable + iterator_archetype( + iterator_archetype< + typename detail::convertible_type::type + , AccessCategory + , TraversalCategory> const& + ); +# endif +}; + +} // namespace boost + + +#endif // BOOST_ITERATOR_ARCHETYPES_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/iterator_categories.hpp b/deal.II/contrib/boost/include/boost/iterator/iterator_categories.hpp new file mode 100644 index 0000000000..085936f7ab --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/iterator_categories.hpp @@ -0,0 +1,188 @@ +// (C) Copyright Jeremy Siek 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_ITERATOR_CATEGORIES_HPP +# define BOOST_ITERATOR_CATEGORIES_HPP + +# include +# include +# include + +# include + +# include +# include +# include +# include + +# include + +# include + +namespace boost { + +// +// Traversal Categories +// + +struct no_traversal_tag {}; + +struct incrementable_traversal_tag + : no_traversal_tag +{ +// incrementable_traversal_tag() {} +// incrementable_traversal_tag(std::output_iterator_tag const&) {}; +}; + +struct single_pass_traversal_tag + : incrementable_traversal_tag +{ +// single_pass_traversal_tag() {} +// single_pass_traversal_tag(std::input_iterator_tag const&) {}; +}; + +struct forward_traversal_tag + : single_pass_traversal_tag +{ +// forward_traversal_tag() {} +// forward_traversal_tag(std::forward_iterator_tag const&) {}; +}; + +struct bidirectional_traversal_tag + : forward_traversal_tag +{ +// bidirectional_traversal_tag() {}; +// bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {}; +}; + +struct random_access_traversal_tag + : bidirectional_traversal_tag +{ +// random_access_traversal_tag() {}; +// random_access_traversal_tag(std::random_access_iterator_tag const&) {}; +}; + +namespace detail +{ + // + // Convert a "strictly old-style" iterator category to a traversal + // tag. This is broken out into a separate metafunction to reduce + // the cost of instantiating iterator_category_to_traversal, below, + // for new-style types. + // + template + struct old_category_to_traversal + : mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , void + > + > + > + > + > + {}; + +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) + template <> + struct old_category_to_traversal + { + typedef int type; + }; +# endif + + template + struct pure_traversal_tag + : mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , void + > + > + > + > + > + { + }; + +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) + template <> + struct pure_traversal_tag + { + typedef int type; + }; +# endif + +} // namespace detail + + +// +// Convert an iterator category into a traversal tag +// +template +struct iterator_category_to_traversal + : mpl::eval_if< // if already convertible to a traversal tag, we're done. + is_convertible + , mpl::identity + , detail::old_category_to_traversal + > +{}; + +// Trait to get an iterator's traversal category +template +struct iterator_traversal + : iterator_category_to_traversal< + typename boost::detail::iterator_traits::iterator_category + > +{}; + +# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT +// Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work +// out well. Instantiating the nested apply template also +// requires instantiating iterator_traits on the +// placeholder. Instead we just specialize it as a metafunction +// class. +template <> +struct iterator_traversal +{ + template + struct apply : iterator_traversal + {}; +}; +template <> +struct iterator_traversal + : iterator_traversal +{}; +# endif + +} // namespace boost + +#include + +#endif // BOOST_ITERATOR_CATEGORIES_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/iterator_concepts.hpp b/deal.II/contrib/boost/include/boost/iterator/iterator_concepts.hpp new file mode 100644 index 0000000000..4c27964e93 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/iterator_concepts.hpp @@ -0,0 +1,308 @@ +// (C) Copyright Jeremy Siek 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_ITERATOR_CONCEPTS_HPP +#define BOOST_ITERATOR_CONCEPTS_HPP + +// Revision History +// 26 Apr 2003 thw +// Adapted to new iterator concepts +// 22 Nov 2002 Thomas Witt +// Added interoperable concept. + +#include +#include + +// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems. +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include + +// Use boost/limits to work around missing limits headers on some compilers +#include +#include + +#include + +namespace boost_concepts { + // Used a different namespace here (instead of "boost") so that the + // concept descriptions do not take for granted the names in + // namespace boost. + + // We use this in place of STATIC_ASSERT((is_convertible<...>)) + // because some compilers (CWPro7.x) can't detect convertibility. + // + // Of course, that just gets us a different error at the moment with + // some tests, since new iterator category deduction still depends + // on convertibility detection. We might need some specializations + // to support this compiler. + template + struct static_assert_base_and_derived + { + static_assert_base_and_derived(Target* = (Source*)0) {} + }; + + //=========================================================================== + // Iterator Access Concepts + + template + class ReadableIteratorConcept { + public: + typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type value_type; + + void constraints() { + boost::function_requires< boost::AssignableConcept >(); + boost::function_requires< boost::CopyConstructibleConcept >(); + + value_type v = *i; + boost::ignore_unused_variable_warning(v); + } + Iterator i; + }; + + template < + typename Iterator + , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type + > + class WritableIteratorConcept { + public: + + void constraints() { + boost::function_requires< boost::CopyConstructibleConcept >(); + *i = v; + } + ValueType v; + Iterator i; + }; + + template + class SwappableIteratorConcept { + public: + + void constraints() { + std::iter_swap(i1, i2); + } + Iterator i1; + Iterator i2; + }; + + template + class LvalueIteratorConcept + { + public: + typedef typename boost::detail::iterator_traits::value_type value_type; + void constraints() + { + value_type& r = const_cast(*i); + boost::ignore_unused_variable_warning(r); + } + Iterator i; + }; + + + //=========================================================================== + // Iterator Traversal Concepts + + template + class IncrementableIteratorConcept { + public: + typedef typename boost::iterator_traversal::type traversal_category; + + void constraints() { + boost::function_requires< boost::AssignableConcept >(); + boost::function_requires< boost::CopyConstructibleConcept >(); + + BOOST_STATIC_ASSERT( + (boost::is_convertible< + traversal_category + , boost::incrementable_traversal_tag + >::value + )); + + ++i; + (void)i++; + } + Iterator i; + }; + + template + class SinglePassIteratorConcept { + public: + typedef typename boost::iterator_traversal::type traversal_category; + typedef typename boost::detail::iterator_traits::difference_type difference_type; + + void constraints() { + boost::function_requires< IncrementableIteratorConcept >(); + boost::function_requires< boost::EqualityComparableConcept >(); + + BOOST_STATIC_ASSERT( + (boost::is_convertible< + traversal_category + , boost::single_pass_traversal_tag + >::value + )); + } + }; + + template + class ForwardTraversalConcept { + public: + typedef typename boost::iterator_traversal::type traversal_category; + typedef typename boost::detail::iterator_traits::difference_type difference_type; + + void constraints() { + boost::function_requires< SinglePassIteratorConcept >(); + boost::function_requires< + boost::DefaultConstructibleConcept >(); + + typedef boost::mpl::and_< + boost::is_integral, + boost::mpl::bool_< std::numeric_limits::is_signed > + > difference_type_is_signed_integral; + + BOOST_STATIC_ASSERT(difference_type_is_signed_integral::value); + BOOST_STATIC_ASSERT( + (boost::is_convertible< + traversal_category + , boost::forward_traversal_tag + >::value + )); + } + }; + + template + class BidirectionalTraversalConcept { + public: + typedef typename boost::iterator_traversal::type traversal_category; + + void constraints() { + boost::function_requires< ForwardTraversalConcept >(); + + BOOST_STATIC_ASSERT( + (boost::is_convertible< + traversal_category + , boost::bidirectional_traversal_tag + >::value + )); + + --i; + (void)i--; + } + Iterator i; + }; + + template + class RandomAccessTraversalConcept { + public: + typedef typename boost::iterator_traversal::type traversal_category; + typedef typename boost::detail::iterator_traits::difference_type + difference_type; + + void constraints() { + boost::function_requires< BidirectionalTraversalConcept >(); + + BOOST_STATIC_ASSERT( + (boost::is_convertible< + traversal_category + , boost::random_access_traversal_tag + >::value + )); + + i += n; + i = i + n; + i = n + i; + i -= n; + i = i - n; + n = i - j; + } + difference_type n; + Iterator i, j; + }; + + //=========================================================================== + // Iterator Interoperability Concept + + namespace detail + { + + template + void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2) + { + bool b; + b = i1 == i2; + b = i1 != i2; + + b = i2 == i1; + b = i2 != i1; + } + + template + void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2, + boost::random_access_traversal_tag, boost::random_access_traversal_tag) + { + bool b; + typename boost::detail::iterator_traits::difference_type n; + b = i1 < i2; + b = i1 <= i2; + b = i1 > i2; + b = i1 >= i2; + n = i1 - i2; + + b = i2 < i1; + b = i2 <= i1; + b = i2 > i1; + b = i2 >= i1; + n = i2 - i1; + } + template + void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2, + boost::single_pass_traversal_tag, boost::single_pass_traversal_tag) + { } + + } // namespace detail + + template + class InteroperableIteratorConcept + { + public: + typedef typename boost::detail::pure_traversal_tag< + typename boost::iterator_traversal< + Iterator + >::type + >::type traversal_category; + + typedef typename boost::detail::pure_traversal_tag< + typename boost::iterator_traversal< + ConstIterator + >::type + >::type const_traversal_category; + + void constraints() + { + boost::function_requires< SinglePassIteratorConcept >(); + boost::function_requires< SinglePassIteratorConcept >(); + + detail::interop_single_pass_constraints(i, ci); + detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category()); + + ci = i; + } + Iterator i; + ConstIterator ci; + }; + +} // namespace boost_concepts + + +#endif // BOOST_ITERATOR_CONCEPTS_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/iterator_facade.hpp b/deal.II/contrib/boost/include/boost/iterator/iterator_facade.hpp new file mode 100644 index 0000000000..ddb237d324 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/iterator_facade.hpp @@ -0,0 +1,879 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP +#define BOOST_ITERATOR_FACADE_23022003THW_HPP + +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include // this goes last + +namespace boost +{ + // This forward declaration is required for the friend declaration + // in iterator_core_access + template class iterator_facade; + + namespace detail + { + // A binary metafunction class that always returns bool. VC6 + // ICEs on mpl::always, probably because of the default + // parameters. + struct always_bool2 + { + template + struct apply + { + typedef bool type; + }; + }; + + // + // enable if for use in operator implementation. + // + template < + class Facade1 + , class Facade2 + , class Return + > + struct enable_if_interoperable +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + { + typedef typename mpl::if_< + mpl::or_< + is_convertible + , is_convertible + > + , Return + , int[3] + >::type type; + }; +#else + : ::boost::iterators::enable_if< + mpl::or_< + is_convertible + , is_convertible + > + , Return + > + {}; +#endif + + // + // Generates associated types for an iterator_facade with the + // given parameters. + // + template < + class ValueParam + , class CategoryOrTraversal + , class Reference + , class Difference + > + struct iterator_facade_types + { + typedef typename facade_iterator_category< + CategoryOrTraversal, ValueParam, Reference + >::type iterator_category; + + typedef typename remove_const::type value_type; + + typedef typename mpl::eval_if< + detail::iterator_writability_disabled + , add_pointer + , add_pointer + >::type pointer; + +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \ + || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \ + || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)) \ + || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310) + + // To interoperate with some broken library/compiler + // combinations, user-defined iterators must be derived from + // std::iterator. It is possible to implement a standard + // library for broken compilers without this limitation. +# define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1 + + typedef + iterator + base; +# endif + }; + + // iterators whose dereference operators reference the same value + // for all iterators into the same sequence (like many input + // iterators) need help with their postfix ++: the referenced + // value must be read and stored away before the increment occurs + // so that *a++ yields the originally referenced element and not + // the next one. + template + class postfix_increment_proxy + { + typedef typename iterator_value::type value_type; + public: + explicit postfix_increment_proxy(Iterator const& x) + : stored_value(*x) + {} + + // Returning a mutable reference allows nonsense like + // (*r++).mutate(), but it imposes fewer assumptions about the + // behavior of the value_type. In particular, recall taht + // (*r).mutate() is legal if operator* returns by value. + value_type& + operator*() const + { + return this->stored_value; + } + private: + mutable value_type stored_value; + }; + + // + // In general, we can't determine that such an iterator isn't + // writable -- we also need to store a copy of the old iterator so + // that it can be written into. + template + class writable_postfix_increment_proxy + { + typedef typename iterator_value::type value_type; + public: + explicit writable_postfix_increment_proxy(Iterator const& x) + : stored_value(*x) + , stored_iterator(x) + {} + + // Dereferencing must return a proxy so that both *r++ = o and + // value_type(*r++) can work. In this case, *r is the same as + // *r++, and the conversion operator below is used to ensure + // readability. + writable_postfix_increment_proxy const& + operator*() const + { + return *this; + } + + // Provides readability of *r++ + operator value_type&() const + { + return stored_value; + } + + // Provides writability of *r++ + template + T const& operator=(T const& x) const + { + *this->stored_iterator = x; + return x; + } + + // This overload just in case only non-const objects are writable + template + T& operator=(T& x) const + { + *this->stored_iterator = x; + return x; + } + + // Provides X(r++) + operator Iterator const&() const + { + return stored_iterator; + } + + private: + mutable value_type stored_value; + Iterator stored_iterator; + }; + +# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + template + struct is_non_proxy_reference_impl + { + static Reference r; + + template + static typename mpl::if_< + is_convertible< + R const volatile* + , Value const volatile* + > + , char[1] + , char[2] + >::type& helper(R const&); + + BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1); + }; + + template + struct is_non_proxy_reference + : mpl::bool_< + is_non_proxy_reference_impl::value + > + {}; +# else + template + struct is_non_proxy_reference + : is_convertible< + typename remove_reference::type + const volatile* + , Value const volatile* + > + {}; +# endif + + // A metafunction to choose the result type of postfix ++ + // + // Because the C++98 input iterator requirements say that *r++ has + // type T (value_type), implementations of some standard + // algorithms like lexicographical_compare may use constructions + // like: + // + // *r++ < *s++ + // + // If *r++ returns a proxy (as required if r is writable but not + // multipass), this sort of expression will fail unless the proxy + // supports the operator<. Since there are any number of such + // operations, we're not going to try to support them. Therefore, + // even if r++ returns a proxy, *r++ will only return a proxy if + // *r also returns a proxy. + template + struct postfix_increment_result + : mpl::eval_if< + mpl::and_< + // A proxy is only needed for readable iterators + is_convertible + + // No multipass iterator can have values that disappear + // before positions can be re-visited + , mpl::not_< + is_convertible< + typename iterator_category_to_traversal::type + , forward_traversal_tag + > + > + > + , mpl::if_< + is_non_proxy_reference + , postfix_increment_proxy + , writable_postfix_increment_proxy + > + , mpl::identity + > + {}; + + // operator->() needs special support for input iterators to strictly meet the + // standard's requirements. If *i is not a reference type, we must still + // produce a (constant) lvalue to which a pointer can be formed. We do that by + // returning an instantiation of this special proxy class template. + template + struct operator_arrow_proxy + { + operator_arrow_proxy(T const* px) : m_value(*px) {} + const T* operator->() const { return &m_value; } + // This function is needed for MWCW and BCC, which won't call operator-> + // again automatically per 13.3.1.2 para 8 + operator const T*() const { return &m_value; } + T m_value; + }; + + // A metafunction that gets the result type for operator->. Also + // has a static function make() which builds the result from a + // Reference + template + struct operator_arrow_result + { + // CWPro8.3 won't accept "operator_arrow_result::type", and we + // need that type below, so metafunction forwarding would be a + // losing proposition here. + typedef typename mpl::if_< + is_reference + , Pointer + , operator_arrow_proxy + >::type type; + + static type make(Reference x) + { + return implicit_cast(&x); + } + }; + +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + // Deal with ETI + template<> + struct operator_arrow_result + { + typedef int type; + }; +# endif + + // A proxy return type for operator[], needed to deal with + // iterators that may invalidate referents upon destruction. + // Consider the temporary iterator in *(a + n) + template + class operator_brackets_proxy + { + // Iterator is actually an iterator_facade, so we do not have to + // go through iterator_traits to access the traits. + typedef typename Iterator::reference reference; + typedef typename Iterator::value_type value_type; + + public: + operator_brackets_proxy(Iterator const& iter) + : m_iter(iter) + {} + + operator reference() const + { + return *m_iter; + } + + operator_brackets_proxy& operator=(value_type const& val) + { + *m_iter = val; + return *this; + } + + private: + Iterator m_iter; + }; + + // A metafunction that determines whether operator[] must return a + // proxy, or whether it can simply return a copy of the value_type. + template + struct use_operator_brackets_proxy + : mpl::not_< + mpl::and_< + // Really we want an is_copy_constructible trait here, + // but is_POD will have to suffice in the meantime. + boost::is_POD + , iterator_writability_disabled + > + > + {}; + + template + struct operator_brackets_result + { + typedef typename mpl::if_< + use_operator_brackets_proxy + , operator_brackets_proxy + , Value + >::type type; + }; + + template + operator_brackets_proxy make_operator_brackets_result(Iterator const& iter, mpl::true_) + { + return operator_brackets_proxy(iter); + } + + template + typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_) + { + return *iter; + } + + struct choose_difference_type + { + template + struct apply + : +# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP + iterator_difference +# elif BOOST_WORKAROUND(BOOST_MSVC, == 1200) + mpl::if_< + is_convertible + , typename I1::difference_type + , typename I2::difference_type + > +# else + mpl::eval_if< + is_convertible + , iterator_difference + , iterator_difference + > +# endif + {}; + + }; + } // namespace detail + + + // Macros which describe the declarations of binary operators +# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY +# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ + template < \ + class Derived1, class V1, class TC1, class R1, class D1 \ + , class Derived2, class V2, class TC2, class R2, class D2 \ + > \ + prefix typename mpl::apply2::type \ + operator op( \ + iterator_facade const& lhs \ + , iterator_facade const& rhs) +# else +# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ + template < \ + class Derived1, class V1, class TC1, class R1, class D1 \ + , class Derived2, class V2, class TC2, class R2, class D2 \ + > \ + prefix typename detail::enable_if_interoperable< \ + Derived1, Derived2 \ + , typename mpl::apply2::type \ + >::type \ + operator op( \ + iterator_facade const& lhs \ + , iterator_facade const& rhs) +# endif + +# define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \ + template \ + prefix Derived operator+ args + + // + // Helper class for granting access to the iterator core interface. + // + // The simple core interface is used by iterator_facade. The core + // interface of a user/library defined iterator type should not be made public + // so that it does not clutter the public interface. Instead iterator_core_access + // should be made friend so that iterator_facade can access the core + // interface through iterator_core_access. + // + class iterator_core_access + { +# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) + // Tasteless as this may seem, making all members public allows member templates + // to work in the absence of member template friends. + public: +# else + + template friend class iterator_facade; + +# define BOOST_ITERATOR_FACADE_RELATION(op) \ + BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, detail::always_bool2); + + BOOST_ITERATOR_FACADE_RELATION(==) + BOOST_ITERATOR_FACADE_RELATION(!=) + + BOOST_ITERATOR_FACADE_RELATION(<) + BOOST_ITERATOR_FACADE_RELATION(>) + BOOST_ITERATOR_FACADE_RELATION(<=) + BOOST_ITERATOR_FACADE_RELATION(>=) +# undef BOOST_ITERATOR_FACADE_RELATION + + BOOST_ITERATOR_FACADE_INTEROP_HEAD( + friend, -, detail::choose_difference_type) + ; + + BOOST_ITERATOR_FACADE_PLUS_HEAD( + friend + , (iterator_facade const& + , typename Derived::difference_type) + ) + ; + + BOOST_ITERATOR_FACADE_PLUS_HEAD( + friend + , (typename Derived::difference_type + , iterator_facade const&) + ) + ; + +# endif + + template + static typename Facade::reference dereference(Facade const& f) + { + return f.dereference(); + } + + template + static void increment(Facade& f) + { + f.increment(); + } + + template + static void decrement(Facade& f) + { + f.decrement(); + } + + template + static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_) + { + return f1.equal(f2); + } + + template + static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_) + { + return f2.equal(f1); + } + + template + static void advance(Facade& f, typename Facade::difference_type n) + { + f.advance(n); + } + + template + static typename Facade1::difference_type distance_from( + Facade1 const& f1, Facade2 const& f2, mpl::true_) + { + return -f1.distance_to(f2); + } + + template + static typename Facade2::difference_type distance_from( + Facade1 const& f1, Facade2 const& f2, mpl::false_) + { + return f2.distance_to(f1); + } + + // + // Curiously Recurring Template interface. + // + template + static I& derived(iterator_facade& facade) + { + return *static_cast(&facade); + } + + template + static I const& derived(iterator_facade const& facade) + { + return *static_cast(&facade); + } + + private: + // objects of this class are useless + iterator_core_access(); //undefined + }; + + // + // iterator_facade - use as a public base class for defining new + // standard-conforming iterators. + // + template < + class Derived // The derived iterator type being constructed + , class Value + , class CategoryOrTraversal + , class Reference = Value& + , class Difference = std::ptrdiff_t + > + class iterator_facade +# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE + : public detail::iterator_facade_types< + Value, CategoryOrTraversal, Reference, Difference + >::base +# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE +# endif + { + private: + // + // Curiously Recurring Template interface. + // + Derived& derived() + { + return *static_cast(this); + } + + Derived const& derived() const + { + return *static_cast(this); + } + + typedef detail::iterator_facade_types< + Value, CategoryOrTraversal, Reference, Difference + > associated_types; + + protected: + // For use by derived classes + typedef iterator_facade iterator_facade_; + + public: + + typedef typename associated_types::value_type value_type; + typedef Reference reference; + typedef Difference difference_type; + typedef typename associated_types::pointer pointer; + typedef typename associated_types::iterator_category iterator_category; + + reference operator*() const + { + return iterator_core_access::dereference(this->derived()); + } + + typename detail::operator_arrow_result< + value_type + , reference + , pointer + >::type + operator->() const + { + return detail::operator_arrow_result< + value_type + , reference + , pointer + >::make(*this->derived()); + } + + typename detail::operator_brackets_result::type + operator[](difference_type n) const + { + typedef detail::use_operator_brackets_proxy use_proxy; + + return detail::make_operator_brackets_result( + this->derived() + n + , use_proxy() + ); + } + + Derived& operator++() + { + iterator_core_access::increment(this->derived()); + return this->derived(); + } + +# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) + typename detail::postfix_increment_result::type + operator++(int) + { + typename detail::postfix_increment_result::type + tmp(this->derived()); + ++*this; + return tmp; + } +# endif + + Derived& operator--() + { + iterator_core_access::decrement(this->derived()); + return this->derived(); + } + + Derived operator--(int) + { + Derived tmp(this->derived()); + --*this; + return tmp; + } + + Derived& operator+=(difference_type n) + { + iterator_core_access::advance(this->derived(), n); + return this->derived(); + } + + Derived& operator-=(difference_type n) + { + iterator_core_access::advance(this->derived(), -n); + return this->derived(); + } + + Derived operator-(difference_type x) const + { + Derived result(this->derived()); + return result -= x; + } + +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + // There appears to be a bug which trashes the data of classes + // derived from iterator_facade when they are assigned unless we + // define this assignment operator. This bug is only revealed + // (so far) in STLPort debug mode, but it's clearly a codegen + // problem so we apply the workaround for all MSVC6. + iterator_facade& operator=(iterator_facade const&) + { + return *this; + } +# endif + }; + +# if !BOOST_WORKAROUND(BOOST_MSVC, == 1200) + template + typename detail::postfix_increment_result::type + operator++( + iterator_facade& i + , int + ) + { + typename detail::postfix_increment_result::type + tmp(*static_cast(&i)); + + ++i; + + return tmp; + } +# endif + + + // + // Comparison operator implementation. The library supplied operators + // enables the user to provide fully interoperable constant/mutable + // iterator types. I.e. the library provides all operators + // for all mutable/constant iterator combinations. + // + // Note though that this kind of interoperability for constant/mutable + // iterators is not required by the standard for container iterators. + // All the standard asks for is a conversion mutable -> constant. + // Most standard library implementations nowadays provide fully interoperable + // iterator implementations, but there are still heavily used implementations + // that do not provide them. (Actually it's even worse, they do not provide + // them for only a few iterators.) + // + // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should + // enable the user to turn off mixed type operators + // + // The library takes care to provide only the right operator overloads. + // I.e. + // + // bool operator==(Iterator, Iterator); + // bool operator==(ConstIterator, Iterator); + // bool operator==(Iterator, ConstIterator); + // bool operator==(ConstIterator, ConstIterator); + // + // ... + // + // In order to do so it uses c++ idioms that are not yet widely supported + // by current compiler releases. The library is designed to degrade gracefully + // in the face of compiler deficiencies. In general compiler + // deficiencies result in less strict error checking and more obscure + // error messages, functionality is not affected. + // + // For full operation compiler support for "Substitution Failure Is Not An Error" + // (aka. enable_if) and boost::is_convertible is required. + // + // The following problems occur if support is lacking. + // + // Pseudo code + // + // --------------- + // AdaptorA a1; + // AdaptorA a2; + // + // // This will result in a no such overload error in full operation + // // If enable_if or is_convertible is not supported + // // The instantiation will fail with an error hopefully indicating that + // // there is no operator== for Iterator1, Iterator2 + // // The same will happen if no enable_if is used to remove + // // false overloads from the templated conversion constructor + // // of AdaptorA. + // + // a1 == a2; + // ---------------- + // + // AdaptorA a; + // AdaptorB b; + // + // // This will result in a no such overload error in full operation + // // If enable_if is not supported the static assert used + // // in the operator implementation will fail. + // // This will accidently work if is_convertible is not supported. + // + // a == b; + // ---------------- + // + +# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP +# define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_() +# else +# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() +# endif + +# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \ + BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) \ + { \ + /* For those compilers that do not support enable_if */ \ + BOOST_STATIC_ASSERT(( \ + is_interoperable< Derived1, Derived2 >::value \ + )); \ + return_prefix iterator_core_access::base_op( \ + *static_cast(&lhs) \ + , *static_cast(&rhs) \ + , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ + ); \ + } + +# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \ + BOOST_ITERATOR_FACADE_INTEROP( \ + op \ + , detail::always_bool2 \ + , return_prefix \ + , base_op \ + ) + + BOOST_ITERATOR_FACADE_RELATION(==, return, equal) + BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal) + + BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from) + BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from) + BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from) + BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from) +# undef BOOST_ITERATOR_FACADE_RELATION + + // operator- requires an additional part in the static assertion + BOOST_ITERATOR_FACADE_INTEROP( + - + , detail::choose_difference_type + , return + , distance_from + ) +# undef BOOST_ITERATOR_FACADE_INTEROP +# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD + +# define BOOST_ITERATOR_FACADE_PLUS(args) \ + BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) \ + { \ + Derived tmp(static_cast(i)); \ + return tmp += n; \ + } + +BOOST_ITERATOR_FACADE_PLUS(( + iterator_facade const& i + , typename Derived::difference_type n +)) + +BOOST_ITERATOR_FACADE_PLUS(( + typename Derived::difference_type n + , iterator_facade const& i +)) +# undef BOOST_ITERATOR_FACADE_PLUS +# undef BOOST_ITERATOR_FACADE_PLUS_HEAD + +} // namespace boost + +#include + +#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/iterator_traits.hpp b/deal.II/contrib/boost/include/boost/iterator/iterator_traits.hpp new file mode 100644 index 0000000000..93e282efb2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/iterator_traits.hpp @@ -0,0 +1,92 @@ +// Copyright David Abrahams 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) +#ifndef ITERATOR_TRAITS_DWA200347_HPP +# define ITERATOR_TRAITS_DWA200347_HPP + +# include +# include + +namespace boost { + +// Unfortunately, g++ 2.95.x chokes when we define a class template +// iterator_category which has the same name as its +// std::iterator_category() function, probably due in part to the +// "std:: is visible globally" hack it uses. Use +// BOOST_ITERATOR_CATEGORY to write code that's portable to older +// GCCs. + +# if BOOST_WORKAROUND(__GNUC__, <= 2) +# define BOOST_ITERATOR_CATEGORY iterator_category_ +# else +# define BOOST_ITERATOR_CATEGORY iterator_category +# endif + + +template +struct iterator_value +{ + typedef typename detail::iterator_traits::value_type type; +}; + +template +struct iterator_reference +{ + typedef typename detail::iterator_traits::reference type; +}; + + +template +struct iterator_pointer +{ + typedef typename detail::iterator_traits::pointer type; +}; + +template +struct iterator_difference +{ + typedef typename detail::iterator_traits::difference_type type; +}; + +template +struct BOOST_ITERATOR_CATEGORY +{ + typedef typename detail::iterator_traits::iterator_category type; +}; + +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) +template <> +struct iterator_value +{ + typedef void type; +}; + +template <> +struct iterator_reference +{ + typedef void type; +}; + +template <> +struct iterator_pointer +{ + typedef void type; +}; + +template <> +struct iterator_difference +{ + typedef void type; +}; + +template <> +struct BOOST_ITERATOR_CATEGORY +{ + typedef void type; +}; +# endif + +} // namespace boost::iterator + +#endif // ITERATOR_TRAITS_DWA200347_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/new_iterator_tests.hpp b/deal.II/contrib/boost/include/boost/iterator/new_iterator_tests.hpp new file mode 100644 index 0000000000..8bb47b01ce --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/new_iterator_tests.hpp @@ -0,0 +1,264 @@ +#ifndef BOOST_NEW_ITERATOR_TESTS_HPP +# define BOOST_NEW_ITERATOR_TESTS_HPP + +// +// Copyright (c) David Abrahams 2001. +// Copyright (c) Jeremy Siek 2001-2003. +// Copyright (c) Thomas Witt 2002. +// +// Use, modification and distribution is subject to the +// Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// This is meant to be the beginnings of a comprehensive, generic +// test suite for STL concepts such as iterators and containers. +// +// Revision History: +// 28 Oct 2002 Started update for new iterator categories +// (Jeremy Siek) +// 28 Apr 2002 Fixed input iterator requirements. +// For a == b a++ == b++ is no longer required. +// See 24.1.1/3 for details. +// (Thomas Witt) +// 08 Feb 2001 Fixed bidirectional iterator test so that +// --i is no longer a precondition. +// (Jeremy Siek) +// 04 Feb 2001 Added lvalue test, corrected preconditions +// (David Abrahams) + +# include +# include +# include +# include +# include // for detail::dummy_constructor +# include +# include +# include +# include + +# include +# include + +namespace boost { + + +// Do separate tests for *i++ so we can treat, e.g., smart pointers, +// as readable and/or writable iterators. +template +void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_) +{ + T v2(*i1++); + assert(v == v2); +} + +template +void readable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) +{} + +template +void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_) +{ + ++i1; // we just wrote into that position + *i1++ = v; + Iterator x(i1++); + (void)x; +} + +template +void writable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) +{} + + +// Preconditions: *i == v +template +void readable_iterator_test(const Iterator i1, T v) +{ + Iterator i2(i1); // Copy Constructible + typedef typename detail::iterator_traits::reference ref_t; + ref_t r1 = *i1; + ref_t r2 = *i2; + T v1 = r1; + T v2 = r2; + assert(v1 == v); + assert(v2 == v); + +# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) + readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable()); + + // I think we don't really need this as it checks the same things as + // the above code. + BOOST_STATIC_ASSERT(is_readable_iterator::value); +# endif +} + +template +void writable_iterator_test(Iterator i, T v, T v2) +{ + Iterator i2(i); // Copy Constructible + *i2 = v; + +# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) + writable_iterator_traversal_test( + i, v2, mpl::and_< + detail::is_incrementable + , detail::is_postfix_incrementable + >()); +# endif +} + +template +void swappable_iterator_test(Iterator i, Iterator j) +{ + Iterator i2(i), j2(j); + typename detail::iterator_traits::value_type bi = *i, bj = *j; + iter_swap(i2, j2); + typename detail::iterator_traits::value_type ai = *i, aj = *j; + assert(bi == aj && bj == ai); +} + +template +void constant_lvalue_iterator_test(Iterator i, T v1) +{ + Iterator i2(i); + typedef typename detail::iterator_traits::value_type value_type; + typedef typename detail::iterator_traits::reference reference; + BOOST_STATIC_ASSERT((is_same::value)); + const T& v2 = *i2; + assert(v1 == v2); +# ifndef BOOST_NO_LVALUE_RETURN_DETECTION + BOOST_STATIC_ASSERT(is_lvalue_iterator::value); + BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator::value); +# endif +} + +template +void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) +{ + Iterator i2(i); + typedef typename detail::iterator_traits::value_type value_type; + typedef typename detail::iterator_traits::reference reference; + BOOST_STATIC_ASSERT((is_same::value)); + T& v3 = *i2; + assert(v1 == v3); + + // A non-const lvalue iterator is not neccessarily writable, but we + // are assuming the value_type is assignable here + *i = v2; + + T& v4 = *i2; + assert(v2 == v4); +# ifndef BOOST_NO_LVALUE_RETURN_DETECTION + BOOST_STATIC_ASSERT(is_lvalue_iterator::value); + BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator::value); +# endif +} + +template +void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) +{ + Iterator i2; + Iterator i3(i); + i2 = i; + assert(i2 == i3); + assert(i != j); + assert(i2 != j); + readable_iterator_test(i, val1); + readable_iterator_test(i2, val1); + readable_iterator_test(i3, val1); + + assert(i == i2++); + assert(i != ++i3); + + readable_iterator_test(i2, val2); + readable_iterator_test(i3, val2); + + readable_iterator_test(i, val1); +} + +template +void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) +{ + forward_readable_iterator_test(i, j, val1, val2); + Iterator i2 = i; + ++i2; + swappable_iterator_test(i, i2); +} + +// bidirectional +// Preconditions: *i == v1, *++i == v2 +template +void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) +{ + Iterator j(i); + ++j; + forward_readable_iterator_test(i, j, v1, v2); + ++i; + + Iterator i1 = i, i2 = i; + + assert(i == i1--); + assert(i != --i2); + + readable_iterator_test(i, v2); + readable_iterator_test(i1, v1); + readable_iterator_test(i2, v1); + + --i; + assert(i == i1); + assert(i == i2); + ++i1; + ++i2; + + readable_iterator_test(i, v1); + readable_iterator_test(i1, v2); + readable_iterator_test(i2, v2); +} + +// random access +// Preconditions: [i,i+N) is a valid range +template +void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) +{ + bidirectional_readable_iterator_test(i, vals[0], vals[1]); + const Iterator j = i; + int c; + + for (c = 0; c < N-1; ++c) + { + assert(i == j + c); + assert(*i == vals[c]); + typename detail::iterator_traits::value_type x = j[c]; + assert(*i == x); + assert(*i == *(j + c)); + assert(*i == *(c + j)); + ++i; + assert(i > j); + assert(i >= j); + assert(j <= i); + assert(j < i); + } + + Iterator k = j + N - 1; + for (c = 0; c < N-1; ++c) + { + assert(i == k - c); + assert(*i == vals[N - 1 - c]); + typename detail::iterator_traits::value_type x = j[N - 1 - c]; + assert(*i == x); + Iterator q = k - c; + assert(*i == *q); + assert(i > j); + assert(i >= j); + assert(j <= i); + assert(j < i); + --i; + } +} + +} // namespace boost + +# include + +#endif // BOOST_NEW_ITERATOR_TESTS_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/permutation_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/permutation_iterator.hpp new file mode 100644 index 0000000000..1cd01189a7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/permutation_iterator.hpp @@ -0,0 +1,67 @@ +// (C) Copyright Toon Knapen 2001. +// (C) Copyright David Abrahams 2003. +// (C) Copyright Roland Richter 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) + +#ifndef BOOST_PERMUTATION_ITERATOR_HPP +#define BOOST_PERMUTATION_ITERATOR_HPP + +#include + +#include + + +namespace boost +{ + +template< class ElementIterator + , class IndexIterator> +class permutation_iterator + : public iterator_adaptor< + permutation_iterator + , IndexIterator, typename detail::iterator_traits::value_type + , use_default, typename detail::iterator_traits::reference> +{ + typedef iterator_adaptor< + permutation_iterator + , IndexIterator, typename detail::iterator_traits::value_type + , use_default, typename detail::iterator_traits::reference> super_t; + + friend class iterator_core_access; + +public: + permutation_iterator() : m_elt_iter() {} + + explicit permutation_iterator(ElementIterator x, IndexIterator y) + : super_t(y), m_elt_iter(x) {} + + template + permutation_iterator( + permutation_iterator const& r + , typename enable_if_convertible::type* = 0 + , typename enable_if_convertible::type* = 0 + ) + : super_t(r.base()), m_elt_iter(r.m_elt_iter) + {} + +private: + typename super_t::reference dereference() const + { return *(m_elt_iter + *this->base()); } + + ElementIterator m_elt_iter; +}; + + +template +permutation_iterator +make_permutation_iterator( ElementIterator e, IndexIterator i ) +{ + return permutation_iterator( e, i ); +} + + +} // namespace boost + +#endif diff --git a/deal.II/contrib/boost/include/boost/iterator/reverse_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/reverse_iterator.hpp new file mode 100644 index 0000000000..97b6b4861d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/reverse_iterator.hpp @@ -0,0 +1,69 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP +#define BOOST_REVERSE_ITERATOR_23022003THW_HPP + +#include +#include +#include + +namespace boost +{ + + // + // + // + template + class reverse_iterator + : public iterator_adaptor< reverse_iterator, Iterator > + { + typedef iterator_adaptor< reverse_iterator, Iterator > super_t; + + friend class iterator_core_access; + + public: + reverse_iterator() {} + + explicit reverse_iterator(Iterator x) + : super_t(x) {} + + template + reverse_iterator( + reverse_iterator const& r + , typename enable_if_convertible::type* = 0 + ) + : super_t(r.base()) + {} + + private: + typename super_t::reference dereference() const { return *boost::prior(this->base()); } + + void increment() { --this->base_reference(); } + void decrement() { ++this->base_reference(); } + + void advance(typename super_t::difference_type n) + { + this->base_reference() += -n; + } + + template + typename super_t::difference_type + distance_to(reverse_iterator const& y) const + { + return this->base_reference() - y.base(); + } + }; + + template + reverse_iterator make_reverse_iterator(BidirectionalIterator x) + { + return reverse_iterator(x); + } + +} // namespace boost + +#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/transform_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/transform_iterator.hpp new file mode 100644 index 0000000000..d6375271e0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/transform_iterator.hpp @@ -0,0 +1,188 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP +#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) +# include + +#endif +#include + + +namespace boost +{ + template + class transform_iterator; + + namespace detail + { + + template + struct function_object_result + { + typedef typename UnaryFunction::result_type type; + }; + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct function_object_result + { + typedef Return type; + }; +#endif + + // Compute the iterator_adaptor instantiation to be used for transform_iterator + template + struct transform_iterator_base + { + private: + // By default, dereferencing the iterator yields the same as + // the function. Do we need to adjust the way + // function_object_result is computed for the standard + // proposal (e.g. using Doug's result_of)? + typedef typename ia_dflt_help< + Reference + , function_object_result + >::type reference; + + // To get the default for Value: remove any reference on the + // result type, but retain any constness to signal + // non-writability. Note that if we adopt Thomas' suggestion + // to key non-writability *only* on the Reference argument, + // we'd need to strip constness here as well. + typedef typename ia_dflt_help< + Value + , remove_reference + >::type cv_value_type; + + public: + typedef iterator_adaptor< + transform_iterator + , Iterator + , cv_value_type + , use_default // Leave the traversal category alone + , reference + > type; + }; + } + + template + class transform_iterator + : public detail::transform_iterator_base::type + { + typedef typename + detail::transform_iterator_base::type + super_t; + + friend class iterator_core_access; + + public: + transform_iterator() { } + + transform_iterator(Iterator const& x, UnaryFunction f) + : super_t(x), m_f(f) { } + + explicit transform_iterator(Iterator const& x) + : super_t(x) + { + // Pro8 is a little too aggressive about instantiating the + // body of this function. +#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) + // don't provide this constructor if UnaryFunction is a + // function pointer type, since it will be 0. Too dangerous. + BOOST_STATIC_ASSERT(is_class::value); +#endif + } + + template< + class OtherUnaryFunction + , class OtherIterator + , class OtherReference + , class OtherValue> + transform_iterator( + transform_iterator const& t + , typename enable_if_convertible::type* = 0 +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) + , typename enable_if_convertible::type* = 0 +#endif + ) + : super_t(t.base()), m_f(t.functor()) + {} + + UnaryFunction functor() const + { return m_f; } + + private: + typename super_t::reference dereference() const + { return m_f(*this->base()); } + + // Probably should be the initial base class so it can be + // optimized away via EBO if it is an empty class. + UnaryFunction m_f; + }; + + template + transform_iterator + make_transform_iterator(Iterator it, UnaryFunction fun) + { + return transform_iterator(it, fun); + } + + // Version which allows explicit specification of the UnaryFunction + // type. + // + // This generator is not provided if UnaryFunction is a function + // pointer type, because it's too dangerous: the default-constructed + // function pointer in the iterator be 0, leading to a runtime + // crash. + template +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + typename mpl::if_< +#else + typename iterators::enable_if< +#endif + is_class // We should probably find a cheaper test than is_class<> + , transform_iterator +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + , int[3] +#endif + >::type + make_transform_iterator(Iterator it) + { + return transform_iterator(it, UnaryFunction()); + } + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) + template + transform_iterator< Return (*)(Argument), Iterator, Return> + make_transform_iterator(Iterator it, Return (*fun)(Argument)) + { + return transform_iterator(it, fun); + } +#endif + +} // namespace boost + +#include + +#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP diff --git a/deal.II/contrib/boost/include/boost/iterator/zip_iterator.hpp b/deal.II/contrib/boost/include/boost/iterator/zip_iterator.hpp new file mode 100755 index 0000000000..817bbab058 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/iterator/zip_iterator.hpp @@ -0,0 +1,600 @@ +// (C) Copyright David Abrahams and Thomas Becker 2000. Permission to +// copy, use, modify, sell and distribute this software is granted +// provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with +// no claim as to its suitability for any purpose. +// +// Compilers Tested: +// ================= +// Metrowerks Codewarrior Pro 7.2, 8.3 +// gcc 2.95.3 +// gcc 3.2 +// Microsoft VC 6sp5 (test fails due to some compiler bug) +// Microsoft VC 7 (works) +// Microsoft VC 7.1 +// Intel 5 +// Intel 6 +// Intel 7.1 +// Intel 8 +// Borland 5.5.1 (broken due to lack of support from Boost.Tuples) + +#ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_ +# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_ + +#include +#include +#include +#include +#include // for enable_if_convertible +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + // Zip iterator forward declaration for zip_iterator_base + template + class zip_iterator; + + // One important design goal of the zip_iterator is to isolate all + // functionality whose implementation relies on the current tuple + // implementation. This goal has been achieved as follows: Inside + // the namespace detail there is a namespace tuple_impl_specific. + // This namespace encapsulates all functionality that is specific + // to the current Boost tuple implementation. More precisely, the + // namespace tuple_impl_specific provides the following tuple + // algorithms and meta-algorithms for the current Boost tuple + // implementation: + // + // tuple_meta_transform + // tuple_meta_accumulate + // tuple_transform + // tuple_for_each + // + // If the tuple implementation changes, all that needs to be + // replaced is the implementation of these four (meta-)algorithms. + + namespace detail + { + + // Functors to be used with tuple algorithms + // + template + class advance_iterator + { + public: + advance_iterator(DiffType step) : m_step(step) {} + + template + void operator()(Iterator& it) const + { it += m_step; } + + private: + DiffType m_step; + }; + // + struct increment_iterator + { + template + void operator()(Iterator& it) + { ++it; } + }; + // + struct decrement_iterator + { + template + void operator()(Iterator& it) + { --it; } + }; + // + struct dereference_iterator + { + template + struct apply + { + typedef typename + iterator_traits::reference + type; + }; + + template + typename apply::type operator()(Iterator const& it) + { return *it; } + }; + + + // The namespace tuple_impl_specific provides two meta- + // algorithms and two algorithms for tuples. + // + namespace tuple_impl_specific + { + // Meta-transform algorithm for tuples + // + template + struct tuple_meta_transform; + + template + struct tuple_meta_transform_impl + { + typedef tuples::cons< + typename mpl::apply1< + typename mpl::lambda::type + , typename Tuple::head_type + >::type + , typename tuple_meta_transform< + typename Tuple::tail_type + , UnaryMetaFun + >::type + > type; + }; + + template + struct tuple_meta_transform + : mpl::eval_if< + boost::is_same + , mpl::identity + , tuple_meta_transform_impl + > + { + }; + + // Meta-accumulate algorithm for tuples. Note: The template + // parameter StartType corresponds to the initial value in + // ordinary accumulation. + // + template + struct tuple_meta_accumulate; + + template< + typename Tuple + , class BinaryMetaFun + , typename StartType + > + struct tuple_meta_accumulate_impl + { + typedef typename mpl::apply2< + typename mpl::lambda::type + , typename Tuple::head_type + , typename tuple_meta_accumulate< + typename Tuple::tail_type + , BinaryMetaFun + , StartType + >::type + >::type type; + }; + + template< + typename Tuple + , class BinaryMetaFun + , typename StartType + > + struct tuple_meta_accumulate + : mpl::eval_if< +#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) + mpl::or_< +#endif + boost::is_same +#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) + , boost::is_same + > +#endif + , mpl::identity + , tuple_meta_accumulate_impl< + Tuple + , BinaryMetaFun + , StartType + > + > + { + }; + +#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \ + || ( \ + BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, != 0) && defined(_MSC_VER) \ + ) +// Not sure why intel's partial ordering fails in this case, but I'm +// assuming int's an MSVC bug-compatibility feature. + +# define BOOST_TUPLE_ALGO_DISPATCH +# define BOOST_TUPLE_ALGO(algo) algo##_impl +# define BOOST_TUPLE_ALGO_TERMINATOR , int +# define BOOST_TUPLE_ALGO_RECURSE , ... +#else +# define BOOST_TUPLE_ALGO(algo) algo +# define BOOST_TUPLE_ALGO_TERMINATOR +# define BOOST_TUPLE_ALGO_RECURSE +#endif + + // transform algorithm for tuples. The template parameter Fun + // must be a unary functor which is also a unary metafunction + // class that computes its return type based on its argument + // type. For example: + // + // struct to_ptr + // { + // template + // struct apply + // { + // typedef Arg* type; + // } + // + // template + // Arg* operator()(Arg x); + // }; + template + tuples::null_type BOOST_TUPLE_ALGO(tuple_transform) + (tuples::null_type const&, Fun BOOST_TUPLE_ALGO_TERMINATOR) + { return tuples::null_type(); } + + template + typename tuple_meta_transform< + Tuple + , Fun + >::type + + BOOST_TUPLE_ALGO(tuple_transform)( + const Tuple& t, + Fun f + BOOST_TUPLE_ALGO_RECURSE + ) + { + typedef typename tuple_meta_transform< + BOOST_DEDUCED_TYPENAME Tuple::tail_type + , Fun + >::type transformed_tail_type; + + return tuples::cons< + BOOST_DEDUCED_TYPENAME mpl::apply1< + Fun, BOOST_DEDUCED_TYPENAME Tuple::head_type + >::type + , transformed_tail_type + >( + f(boost::tuples::get<0>(t)), tuple_transform(t.get_tail(), f) + ); + } + +#ifdef BOOST_TUPLE_ALGO_DISPATCH + template + typename tuple_meta_transform< + Tuple + , Fun + >::type + + tuple_transform( + const Tuple& t, + Fun f + ) + { + return tuple_transform_impl(t, f, 1); + } +#endif + + // for_each algorithm for tuples. + // + template + Fun BOOST_TUPLE_ALGO(tuple_for_each)( + tuples::null_type + , Fun f BOOST_TUPLE_ALGO_TERMINATOR + ) + { return f; } + + + template + Fun BOOST_TUPLE_ALGO(tuple_for_each)( + Tuple& t + , Fun f BOOST_TUPLE_ALGO_RECURSE) + { + f( t.get_head() ); + return tuple_for_each(t.get_tail(), f); + } + +#ifdef BOOST_TUPLE_ALGO_DISPATCH + template + Fun + tuple_for_each( + Tuple& t, + Fun f + ) + { + return tuple_for_each_impl(t, f, 1); + } +#endif + + // Equality of tuples. NOTE: "==" for tuples currently (7/2003) + // has problems under some compilers, so I just do my own. + // No point in bringing in a bunch of #ifdefs here. This is + // going to go away with the next tuple implementation anyway. + // + bool tuple_equal(tuples::null_type, tuples::null_type) + { return true; } + + template + bool tuple_equal( + Tuple1 const& t1, + Tuple2 const& t2 + ) + { + return t1.get_head() == t2.get_head() && + tuple_equal(t1.get_tail(), t2.get_tail()); + } + } + // + // end namespace tuple_impl_specific + + template + struct iterator_reference + { + typedef typename iterator_traits::reference type; + }; + +#ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work + // out well. Instantiating the nested apply template also + // requires instantiating iterator_traits on the + // placeholder. Instead we just specialize it as a metafunction + // class. + template<> + struct iterator_reference + { + template + struct apply : iterator_reference {}; + }; +#endif + + // Metafunction to obtain the type of the tuple whose element types + // are the reference types of an iterator tuple. + // + template + struct tuple_of_references + : tuple_impl_specific::tuple_meta_transform< + IteratorTuple, + iterator_reference + > + { + }; + + // Metafunction to obtain the minimal traversal tag in a tuple + // of iterators. + // + template + struct minimum_traversal_category_in_iterator_tuple + { + typedef typename tuple_impl_specific::tuple_meta_transform< + IteratorTuple + , iterator_traversal<> + >::type tuple_of_traversal_tags; + + typedef typename tuple_impl_specific::tuple_meta_accumulate< + tuple_of_traversal_tags + , minimum_category<> + , random_access_traversal_tag + >::type type; + }; + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround + template <> + struct minimum_traversal_category_in_iterator_tuple + { + typedef int type; + }; +#endif + + // We need to call tuple_meta_accumulate with mpl::and_ as the + // accumulating functor. To this end, we need to wrap it into + // a struct that has exactly two arguments (that is, template + // parameters) and not five, like mpl::and_ does. + // + template + struct and_with_two_args + : mpl::and_ + { + }; + +# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work + // out well. In this case I think it's an MPL bug + template<> + struct and_with_two_args + { + template + struct apply : mpl::and_ + {}; + }; +# endif + + /////////////////////////////////////////////////////////////////// + // + // Class zip_iterator_base + // + // Builds and exposes the iterator facade type from which the zip + // iterator will be derived. + // + template + struct zip_iterator_base + { + private: + // Reference type is the type of the tuple obtained from the + // iterators' reference types. + typedef typename + detail::tuple_of_references::type reference; + + // Value type is the same as reference type. + typedef reference value_type; + + // Difference type is the first iterator's difference type + typedef typename iterator_traits< + typename tuples::element<0, IteratorTuple>::type + >::difference_type difference_type; + + // Traversal catetgory is the minimum traversal category in the + // iterator tuple. + typedef typename + detail::minimum_traversal_category_in_iterator_tuple< + IteratorTuple + >::type traversal_category; + public: + + // The iterator facade type from which the zip iterator will + // be derived. + typedef iterator_facade< + zip_iterator, + value_type, + traversal_category, + reference, + difference_type + > type; + }; + + template <> + struct zip_iterator_base + { + typedef int type; + }; + } + + ///////////////////////////////////////////////////////////////////// + // + // zip_iterator class definition + // + template + class zip_iterator : + public detail::zip_iterator_base::type + { + + // Typedef super_t as our base class. + typedef typename + detail::zip_iterator_base::type super_t; + + // iterator_core_access is the iterator's best friend. + friend class iterator_core_access; + + public: + + // Construction + // ============ + + // Default constructor + zip_iterator() { } + + // Constructor from iterator tuple + zip_iterator(IteratorTuple iterator_tuple) + : m_iterator_tuple(iterator_tuple) + { } + + // Copy constructor + template + zip_iterator( + const zip_iterator& other, + typename enable_if_convertible< + OtherIteratorTuple, + IteratorTuple + >::type* = 0 + ) : m_iterator_tuple(other.get_iterator_tuple()) + {} + + // Get method for the iterator tuple. + const IteratorTuple& get_iterator_tuple() const + { return m_iterator_tuple; } + + private: + + // Implementation of Iterator Operations + // ===================================== + + // Dereferencing returns a tuple built from the dereferenced + // iterators in the iterator tuple. + typename super_t::reference dereference() const + { + return detail::tuple_impl_specific::tuple_transform( + get_iterator_tuple(), + detail::dereference_iterator() + ); + } + + // Two zip iterators are equal if all iterators in the iterator + // tuple are equal. NOTE: It should be possible to implement this + // as + // + // return get_iterator_tuple() == other.get_iterator_tuple(); + // + // but equality of tuples currently (7/2003) does not compile + // under several compilers. No point in bringing in a bunch + // of #ifdefs here. + // + template + bool equal(const zip_iterator& other) const + { + return detail::tuple_impl_specific::tuple_equal( + get_iterator_tuple(), + other.get_iterator_tuple() + ); + } + + // Advancing a zip iterator means to advance all iterators in the + // iterator tuple. + void advance(typename super_t::difference_type n) + { + detail::tuple_impl_specific::tuple_for_each( + m_iterator_tuple, + detail::advance_iterator(n) + ); + } + // Incrementing a zip iterator means to increment all iterators in + // the iterator tuple. + void increment() + { + detail::tuple_impl_specific::tuple_for_each( + m_iterator_tuple, + detail::increment_iterator() + ); + } + + // Decrementing a zip iterator means to decrement all iterators in + // the iterator tuple. + void decrement() + { + detail::tuple_impl_specific::tuple_for_each( + m_iterator_tuple, + detail::decrement_iterator() + ); + } + + // Distance is calculated using the first iterator in the tuple. + template + typename super_t::difference_type distance_to( + const zip_iterator& other + ) const + { + return boost::tuples::get<0>(other.get_iterator_tuple()) - + boost::tuples::get<0>(this->get_iterator_tuple()); + } + + // Data Members + // ============ + + // The iterator tuple. + IteratorTuple m_iterator_tuple; + + }; + + // Make function for zip iterator + // + template + zip_iterator + make_zip_iterator(IteratorTuple t) + { return zip_iterator(t); } + +} + +#endif diff --git a/deal.II/contrib/boost/include/boost/mpl/O1_size.hpp b/deal.II/contrib/boost/include/boost/mpl/O1_size.hpp new file mode 100644 index 0000000000..04ff381c41 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/O1_size.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_O1_SIZE_HPP_INCLUDED +#define BOOST_MPL_O1_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/O1_size.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// returns sequence size if it's an O(1) operation; otherwise returns -1 +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct O1_size + : O1_size_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, O1_size, (Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, O1_size) + +}} + +#endif // BOOST_MPL_O1_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/O1_size_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/O1_size_fwd.hpp new file mode 100644 index 0000000000..26f8748e7d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/O1_size_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED +#define BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/O1_size_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct O1_size_impl; +template< typename Sequence > struct O1_size; + +}} + +#endif // BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/accumulate.hpp b/deal.II/contrib/boost/include/boost/mpl/accumulate.hpp new file mode 100644 index 0000000000..29065644cb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/accumulate.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_ACCUMULATE_HPP_INCLUDED +#define BOOST_MPL_ACCUMULATE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/accumulate.hpp,v $ +// $Date: 2005/01/19 15:20:21 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(State) + , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) + > +struct accumulate + : fold +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,accumulate,(Sequence,State,ForwardOp)) +}; + +BOOST_MPL_AUX_NA_SPEC(3, accumulate) + +}} + +#endif // BOOST_MPL_ACCUMULATE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/advance.hpp b/deal.II/contrib/boost/include/boost/mpl/advance.hpp new file mode 100644 index 0000000000..4245052859 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/advance.hpp @@ -0,0 +1,76 @@ + +#ifndef BOOST_MPL_ADVANCE_HPP_INCLUDED +#define BOOST_MPL_ADVANCE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/advance.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.9 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation for forward/bidirectional iterators +template< typename Tag > +struct advance_impl +{ + template< typename Iterator, typename N > struct apply + { + typedef typename less< N,long_<0> >::type backward_; + typedef typename if_< backward_, negate, N >::type offset_; + + typedef typename if_< + backward_ + , aux::advance_backward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value > + , aux::advance_forward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value > + >::type f_; + + typedef typename apply_wrap1::type type; + }; +}; + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Iterator) + , typename BOOST_MPL_AUX_NA_PARAM(N) + > +struct advance + : advance_impl< typename tag::type > + ::template apply +{ +}; + +template< + typename Iterator + , BOOST_MPL_AUX_NTTP_DECL(long, N) + > +struct advance_c + : advance_impl< typename tag::type > + ::template apply > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(2, advance) + +}} + +#endif // BOOST_MPL_ADVANCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/advance_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/advance_fwd.hpp new file mode 100644 index 0000000000..4a2fe03198 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/advance_fwd.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED +#define BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/advance_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_COMMON_NAME_WKND(advance) + +template< typename Tag > struct advance_impl; +template< typename Iterator, typename N > struct advance; + +}} + +#endif // BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/alias.hpp b/deal.II/contrib/boost/include/boost/mpl/alias.hpp new file mode 100644 index 0000000000..88a2eeddf1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/alias.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_ALIAS_HPP_INCLUDED +#define BOOST_MPL_ALIAS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/alias.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace { +namespace mpl = boost::mpl; +} + +#endif // BOOST_MPL_ALIAS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/always.hpp b/deal.II/contrib/boost/include/boost/mpl/always.hpp new file mode 100644 index 0000000000..f32cf9fd24 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/always.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED +#define BOOST_MPL_ALWAYS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/always.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Value > struct always +{ + template< + typename T + BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(1, typename T, na) + > + struct apply + { + typedef Value type; + }; +}; + +BOOST_MPL_AUX_ARITY_SPEC(1, always) + +}} + +#endif // BOOST_MPL_ALWAYS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/and.hpp b/deal.II/contrib/boost/include/boost/mpl/and.hpp new file mode 100644 index 0000000000..217c46c306 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/and.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_AND_HPP_INCLUDED +#define BOOST_MPL_AND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/and.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# include +# include +# include +# include + +// agurt, 19/may/04: workaround a conflict with header's +// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)' +// has to be checked in a separate condition, otherwise GCC complains +// about 'and' being an alternative token +#if defined(_MSC_VER) +#if defined(and) +# pragma push_macro("and") +# undef and +# define and(x) +#endif +#endif + +# define BOOST_MPL_PREPROCESSED_HEADER and.hpp +# include + +#if defined(_MSC_VER) +#if defined(and) +# pragma pop_macro("and") +#endif +#endif + +#else + +# define AUX778076_OP_NAME and_ +# define AUX778076_OP_VALUE1 false +# define AUX778076_OP_VALUE2 true +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/apply.hpp new file mode 100644 index 0000000000..f42cee3db1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/apply.hpp @@ -0,0 +1,225 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_APPLY_HPP_INCLUDED +#define BOOST_MPL_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/apply.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.17 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER apply.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_APPLY_PARAMS(param) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ + +# define AUX778076_APPLY_DEF_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ + +# define AUX778076_APPLY_N_PARAMS(n, param) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(n, param, def) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ + /**/ + +# define AUX778076_APPLY_N_SPEC_PARAMS(n, param) \ + BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \ + /**/ + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +# if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) +// real C++ version is already taken care of +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +namespace aux { +// apply_count_args +#define AUX778076_COUNT_ARGS_PREFIX apply +#define AUX778076_COUNT_ARGS_DEFAULT na +#define AUX778076_COUNT_ARGS_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY +#include +} + + +template< + typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na) + > +struct apply + : aux::apply_chooser< + aux::apply_count_args< AUX778076_APPLY_PARAMS(T) >::value + >::template result_< F, AUX778076_APPLY_PARAMS(T) >::type +{ +}; + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE + +# undef AUX778076_APPLY_N_SPEC_PARAMS +# undef AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS +# undef AUX778076_APPLY_N_COMMA_PARAMS +# undef AUX778076_APPLY_N_PARAMS +# undef AUX778076_APPLY_DEF_PARAMS +# undef AUX778076_APPLY_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_APPLY_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply,i_) +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) + : BOOST_PP_CAT(apply_wrap,i_)< + typename lambda::type + AUX778076_APPLY_N_COMMA_PARAMS(i_, T) + > +{ +#else +{ + typedef typename BOOST_PP_CAT(apply_wrap,i_)< + typename lambda::type + AUX778076_APPLY_N_COMMA_PARAMS(i_, T) + >::type type; +#endif + BOOST_MPL_AUX_LAMBDA_SUPPORT( + BOOST_PP_INC(i_) + , BOOST_PP_CAT(apply,i_) + , (F AUX778076_APPLY_N_COMMA_PARAMS(i_,T)) + ) +}; + + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +/// workaround for ETI bug +template<> +struct BOOST_PP_CAT(apply,i_) +{ + typedef int type; +}; +#endif + +# if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +#if i_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY +/// primary template (not a specialization!) +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct apply + : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > +{ +}; +#else +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct apply< F AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(i_, T, na) > + : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > +{ +}; +#endif + +# else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) +namespace aux { + +template<> +struct apply_chooser +{ + template< + typename F, AUX778076_APPLY_PARAMS(typename T) + > + struct result_ + { + typedef BOOST_PP_CAT(apply,i_)< + F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) + > type; + }; +}; + +} // namespace aux +#endif + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE + +# undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/apply_fwd.hpp new file mode 100644 index 0000000000..5b850d331c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/apply_fwd.hpp @@ -0,0 +1,107 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_APPLY_FWD_HPP_INCLUDED +#define BOOST_MPL_APPLY_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/apply_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER apply_fwd.hpp +# include + +#else + +# include +# include +# include +# include +# include + +# include +# include +# include + +// agurt, 15/jan/02: top-level 'apply' template gives an ICE on MSVC +// (for known reasons) +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) +# define BOOST_MPL_CFG_NO_APPLY_TEMPLATE +#endif + +namespace boost { namespace mpl { + +// local macro, #undef-ined at the end of the header +# define AUX778076_APPLY_DEF_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ + +# define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// forward declaration +template< + typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na) + > +struct apply; +#else +namespace aux { +template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser; +} +#endif + +# endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + + +# undef AUX778076_APPLY_N_COMMA_PARAMS +# undef AUX778076_APPLY_DEF_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_APPLY_FWD_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply,i_); + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/apply_wrap.hpp new file mode 100644 index 0000000000..ae58189bff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/apply_wrap.hpp @@ -0,0 +1,200 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_APPLY_WRAP_HPP_INCLUDED +#define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/apply_wrap.hpp,v $ +// $Date: 2004/09/03 15:56:55 $ +// $Revision: 1.3 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER apply_wrap.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_APPLY_WRAP_PARAMS(n, param) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_APPLY_WRAP_SPEC_PARAMS(n, param) \ + BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \ + /**/ + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + + +# undef AUX778076_APPLY_WRAP_SPEC_PARAMS +# undef AUX778076_APPLY_WRAP_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_APPLY_WRAP_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +// MSVC version + +#define AUX778076_MSVC_DTW_NAME BOOST_PP_CAT(msvc_apply,i_) +#define AUX778076_MSVC_DTW_ORIGINAL_NAME apply +#define AUX778076_MSVC_DTW_ARITY i_ +#include + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap,i_) +{ + // Metafunction forwarding confuses vc6 + typedef typename BOOST_PP_CAT(msvc_apply,i_)::template result_< + AUX778076_APPLY_WRAP_PARAMS(i_, T) + >::type type; +}; + +# elif defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +// MWCW/Borland version + +template< + int N, typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap_impl,i_); + +#define BOOST_PP_ITERATION_PARAMS_2 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY - i_, )) +#include BOOST_PP_ITERATE() + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap,i_) + : BOOST_PP_CAT(apply_wrap_impl,i_)< + ::boost::mpl::aux::arity::value + , F + BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) + >::type +{ +}; + +# else +// ISO98 C++, with minor concession to vc7 + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) +#if i_ == 0 + , typename has_apply_ = typename aux::has_apply::type +#endif + > +struct BOOST_PP_CAT(apply_wrap,i_) +// metafunction forwarding confuses MSVC 7.0 +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1300) + : F::template apply< AUX778076_APPLY_WRAP_PARAMS(i_, T) > +{ +#else +{ + typedef typename F::template apply< + AUX778076_APPLY_WRAP_PARAMS(i_, T) + >::type type; +#endif +}; + +#if i_ == 0 && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template< typename F > +struct BOOST_PP_CAT(apply_wrap,i_) + : F::apply +{ +}; +#endif + +# endif // workarounds + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +/// workaround for ETI bug +template<> +struct BOOST_PP_CAT(apply_wrap,i_) +{ + typedef int type; +}; +#endif + +# undef i_ + +///// iteration, depth == 2 + +#elif BOOST_PP_ITERATION_DEPTH() == 2 + +# define j_ BOOST_PP_FRAME_ITERATION(2) + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap_impl,i_)< + BOOST_MPL_PP_ADD(i_, j_) + , F + BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) + > +{ + typedef typename F::template apply< + AUX778076_APPLY_WRAP_PARAMS(i_, T) +#if i_ == 0 && j_ == 0 +/// since the defaults are "lost", we have to pass *something* even for nullary +/// metafunction classes + na +#else + BOOST_PP_COMMA_IF(BOOST_PP_AND(i_, j_)) BOOST_MPL_PP_ENUM(j_, na) +#endif + > type; +}; + +# undef j_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/arg.hpp new file mode 100644 index 0000000000..a96b86aad7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/arg.hpp @@ -0,0 +1,131 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_ARG_HPP_INCLUDED +#define BOOST_MPL_ARG_HPP_INCLUDED + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/arg.hpp,v $ +// $Date: 2004/09/21 13:48:07 $ +// $Revision: 1.12 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER arg.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + +# include +# include +# include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +// local macro, #undef-ined at the end of the header +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ +#else +# define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + + +# undef AUX778076_ARG_N_DEFAULT_PARAMS + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int,arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_ARG_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +#if i_ > 0 + +template<> struct arg +{ + BOOST_STATIC_CONSTANT(int, value = i_); + typedef arg next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na) + > + struct apply + { + typedef BOOST_PP_CAT(U,i_) type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +#else + +template<> struct arg<-1> +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na) + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +#endif // i_ > 0 + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/arg_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/arg_fwd.hpp new file mode 100644 index 0000000000..4c9e3a1850 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/arg_fwd.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED +#define BOOST_MPL_ARG_FWD_HPP_INCLUDED + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/arg_fwd.hpp,v $ +// $Date: 2004/09/28 13:56:58 $ +// $Revision: 1.6 $ + +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arg; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(arg) + +#endif // BOOST_MPL_ARG_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/arithmetic.hpp b/deal.II/contrib/boost/include/boost/mpl/arithmetic.hpp new file mode 100644 index 0000000000..598a728669 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/arithmetic.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_ARITHMETIC_HPP_INCLUDED +#define BOOST_MPL_ARITHMETIC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/arithmetic.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include // deprecated + +#endif // BOOST_MPL_ARITHMETIC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/as_sequence.hpp b/deal.II/contrib/boost/include/boost/mpl/as_sequence.hpp new file mode 100644 index 0000000000..ba3d6f4cde --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/as_sequence.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED +#define BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/as_sequence.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct as_sequence + : if_< is_sequence, T, single_view > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,as_sequence,(T)) +}; + +BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, as_sequence) + +}} + +#endif // BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/assert.hpp b/deal.II/contrib/boost/include/boost/mpl/assert.hpp new file mode 100644 index 0000000000..fa41292fbf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/assert.hpp @@ -0,0 +1,330 @@ + +#ifndef BOOST_MPL_ASSERT_HPP_INCLUDED +#define BOOST_MPL_ASSERT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/assert.hpp,v $ +// $Date: 2004/09/28 13:56:58 $ +// $Revision: 1.13 $ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +#if BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ + || (BOOST_MPL_CFG_GCC != 0) +# define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES +#endif + +#if BOOST_WORKAROUND(__MWERKS__, < 0x3202) \ + || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \ + || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER +#endif + + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +struct failed {}; + +// agurt, 24/aug/04: MSVC 7.1 workaround here and below: return/accept +// 'assert' by reference; can't apply it unconditionally -- apparently it +// degrades quality of GCC diagnostics +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) +# define AUX778076_ASSERT_ARG(x) x& +#else +# define AUX778076_ASSERT_ARG(x) x +#endif + +template< bool C > struct assert { typedef void* type; }; +template<> struct assert { typedef AUX778076_ASSERT_ARG(assert) type; }; + +template< bool C > +int assertion_failed( typename assert::type ); + +template< bool C > +struct assertion +{ + static int failed( assert ); +}; + +template<> +struct assertion +{ + static int failed( void* ); +}; + +struct assert_ +{ +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) + template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {}; +#endif + static assert_ const arg; + enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal }; +}; + + +#if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) + +bool operator==( failed, failed ); +bool operator!=( failed, failed ); +bool operator>( failed, failed ); +bool operator>=( failed, failed ); +bool operator<( failed, failed ); +bool operator<=( failed, failed ); + +#if defined(__EDG_VERSION__) +template< bool (*)(failed, failed), long x, long y > struct assert_relation {}; +# define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation +#else +template< BOOST_MPL_AUX_NTTP_DECL(long, x), BOOST_MPL_AUX_NTTP_DECL(long, y), bool (*)(failed, failed) > +struct assert_relation {}; +# define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation +#endif + +#else // BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES + +boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ ); +boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ ); +boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ ); +boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ ); +boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ ); +boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ ); + +template< assert_::relations r, long x, long y > struct assert_relation {}; + +#endif + + +#if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) + +template< bool > struct assert_arg_pred_impl { typedef int type; }; +template<> struct assert_arg_pred_impl { typedef void* type; }; + +template< typename P > struct assert_arg_pred +{ + typedef typename P::type p_type; + typedef typename assert_arg_pred_impl< p_type::value >::type type; +}; + +template< typename P > struct assert_arg_pred_not +{ + typedef typename P::type p_type; + enum { p = !p_type::value }; + typedef typename assert_arg_pred_impl

::type type; +}; + +template< typename Pred > +failed ************ (Pred::************ + assert_arg( void (*)(Pred), typename assert_arg_pred::type ) + ); + +template< typename Pred > +failed ************ (boost::mpl::not_::************ + assert_not_arg( void (*)(Pred), typename assert_arg_pred_not::type ) + ); + +template< typename Pred > +AUX778076_ASSERT_ARG(assert) +assert_arg( void (*)(Pred), typename assert_arg_pred_not::type ); + +template< typename Pred > +AUX778076_ASSERT_ARG(assert) +assert_not_arg( void (*)(Pred), typename assert_arg_pred::type ); + + +#else // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER + +template< bool c, typename Pred > struct assert_arg_type_impl +{ + typedef failed ************ Pred::* mwcw83_wknd; + typedef mwcw83_wknd ************* type; +}; + +template< typename Pred > struct assert_arg_type_impl +{ + typedef AUX778076_ASSERT_ARG(assert) type; +}; + +template< typename Pred > struct assert_arg_type + : assert_arg_type_impl< BOOST_MPL_AUX_VALUE_WKND(BOOST_MPL_AUX_NESTED_TYPE_WKND(Pred))::value, Pred > +{ +}; + +template< typename Pred > +typename assert_arg_type::type +assert_arg(void (*)(Pred), int); + +template< typename Pred > +typename assert_arg_type< boost::mpl::not_ >::type +assert_not_arg(void (*)(Pred), int); + +# if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) +template< long x, long y, bool (*r)(failed, failed) > +typename assert_arg_type_impl< false,BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) >::type +assert_rel_arg( BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) ); +# else +template< assert_::relations r, long x, long y > +typename assert_arg_type_impl< false,assert_relation >::type +assert_rel_arg( assert_relation ); +# endif + +#endif // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER + +#undef AUX778076_ASSERT_ARG + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + + +// BOOST_MPL_ASSERT((pred)) + +#define BOOST_MPL_ASSERT(pred) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::assert_arg( (void (*) pred)0, 1 ) \ + ) \ + ) \ +}\ +/**/ + +// BOOST_MPL_ASSERT_NOT((pred)) + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_MPL_ASSERT_NOT(pred) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion::failed( \ + boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \ + ) \ + ) \ +}\ +/**/ +#else +# define BOOST_MPL_ASSERT_NOT(pred) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \ + ) \ + ) \ +}\ +/**/ +#endif + +// BOOST_MPL_ASSERT_RELATION(x, ==|!=|<=|<|>=|>, y) + +#if defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) + +# if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed<(x rel y)>( \ + (boost::mpl::failed ************ ( boost::mpl::assert_relation< \ + boost::mpl::assert_::relations( sizeof( \ + boost::mpl::assert_::arg rel boost::mpl::assert_::arg \ + ) ) \ + , x \ + , y \ + >::************)) 0 ) \ + ) \ +} \ +/**/ +# else +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +enum { \ + BOOST_PP_CAT(mpl_assert_rel,__LINE__) = sizeof(boost::mpl::assert_::arg rel boost::mpl::assert_::arg) \ + , BOOST_PP_CAT(mpl_assert_rel_value,__LINE__) = (x rel y) \ + , BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::assert_rel_arg( boost::mpl::assert_relation< \ + boost::mpl::assert_::relations(BOOST_PP_CAT(mpl_assert_rel,__LINE__)) \ + , x \ + , y \ + >() ) \ + ) \ + ) \ +} \ +/**/ +# endif + +#else // !BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES + +# if defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed<(x rel y)>( boost::mpl::assert_rel_arg( \ + boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))() \ + ) ) \ + ) \ +}\ +/**/ +# else +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed<(x rel y)>( (boost::mpl::failed ************ ( \ + boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))::************))0 ) \ + ) \ +}\ +/**/ +# endif + +#endif + + +// BOOST_MPL_ASSERT_MSG( (pred::value), USER_PROVIDED_MESSAGE, (types) ) + +#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) +# define BOOST_MPL_ASSERT_MSG( c, msg, types_ ) \ + struct msg; \ + typedef struct BOOST_PP_CAT(msg,__LINE__) : boost::mpl::assert_ \ + { \ + using boost::mpl::assert_::types; \ + static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \ + { return 0; } \ + } BOOST_PP_CAT(mpl_assert_arg,__LINE__); \ + enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion<(c)>::failed( BOOST_PP_CAT(mpl_assert_arg,__LINE__)::assert_arg() ) \ + ) \ + }\ +/**/ +#else +# define BOOST_MPL_ASSERT_MSG( c, msg, types_ ) \ + struct msg; \ + typedef struct BOOST_PP_CAT(msg,__LINE__) : boost::mpl::assert_ \ + { \ + static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \ + { return 0; } \ + } BOOST_PP_CAT(mpl_assert_arg,__LINE__); \ + enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ + boost::mpl::assertion_failed<(c)>( BOOST_PP_CAT(mpl_assert_arg,__LINE__)::assert_arg() ) \ + ) \ + }\ +/**/ +#endif + +#endif // BOOST_MPL_ASSERT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/at.hpp b/deal.II/contrib/boost/include/boost/mpl/at.hpp new file mode 100644 index 0000000000..403a27911a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/at.hpp @@ -0,0 +1,52 @@ + +#ifndef BOOST_MPL_AT_HPP_INCLUDED +#define BOOST_MPL_AT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/at.hpp,v $ +// $Date: 2004/09/04 01:33:46 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(N) + > +struct at + : at_impl< typename sequence_tag::type > + ::template apply< Sequence,N > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,at,(Sequence,N)) +}; + +template< + typename Sequence + , BOOST_MPL_AUX_NTTP_DECL(long, N) + > +struct at_c + : at_impl< typename sequence_tag::type > + ::template apply< Sequence,mpl::long_ > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(2, at) + +}} + +#endif // BOOST_MPL_AT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/at_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/at_fwd.hpp new file mode 100644 index 0000000000..941101ec5e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/at_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_AT_FWD_HPP_INCLUDED +#define BOOST_MPL_AT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/at_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct at_impl; +template< typename Sequence, typename N > struct at; + +}} + +#endif // BOOST_MPL_AT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/O1_size_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/O1_size_impl.hpp new file mode 100644 index 0000000000..ac4e8c3c5e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/O1_size_impl.hpp @@ -0,0 +1,87 @@ + +#ifndef BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED +#define BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/O1_size_impl.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation - returns 'Sequence::size' if sequence has a 'size' +// member, and -1 otherwise; conrete sequences might override it by +// specializing either the 'O1_size_impl' or the primary 'O1_size' template + +# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) \ + && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) + +namespace aux { +template< typename Sequence > struct O1_size_impl + : Sequence::size +{ +}; +} + +template< typename Tag > +struct O1_size_impl +{ + template< typename Sequence > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : if_< + aux::has_size + , aux::O1_size_impl + , long_<-1> + >::type + { +#else + { + typedef typename if_< + aux::has_size + , aux::O1_size_impl + , long_<-1> + >::type type; + + BOOST_STATIC_CONSTANT(long, value = + (if_< + aux::has_size + , aux::O1_size_impl + , long_<-1> + >::type::value) + ); +#endif + }; +}; + +# else // BOOST_MSVC + +template< typename Tag > +struct O1_size_impl +{ + template< typename Sequence > struct apply + : long_<-1> + { + }; +}; + +# endif + +}} + +#endif // BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/adl_barrier.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/adl_barrier.hpp index 2b98d15344..1480ee9fac 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/adl_barrier.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/adl_barrier.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/adl_barrier.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/advance_backward.hpp new file mode 100644 index 0000000000..51bcf035b2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/advance_backward.hpp @@ -0,0 +1,124 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED +#define BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/advance_backward.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.9 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER advance_backward.hpp +# include + +#else + +# include +# include +# include + +# include +# include +# include + +namespace boost { namespace mpl { namespace aux { + +// forward declaration +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_backward; + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) +# include BOOST_PP_ITERATE() + +// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - BOOST_MPL_LIMIT_UNROLLING) < 0 + ? 0 + : N - BOOST_MPL_LIMIT_UNROLLING + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template<> +struct advance_backward< BOOST_PP_FRAME_ITERATION(1) > +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + +#if i_ > 0 +# define BOOST_PP_ITERATION_PARAMS_2 \ + (3,(1, BOOST_PP_FRAME_ITERATION(1), )) +# include BOOST_PP_ITERATE() +#endif + + typedef BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(1)) type; + }; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + /// ETI workaround + template<> struct apply + { + typedef int type; + }; +#endif +}; + +#undef i_ + +///// iteration, depth == 2 + +#elif BOOST_PP_ITERATION_DEPTH() == 2 + +# define AUX778076_ITER_0 BOOST_PP_CAT(iter,BOOST_PP_DEC(BOOST_PP_FRAME_ITERATION(2))) +# define AUX778076_ITER_1 BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(2)) + + typedef typename prior::type AUX778076_ITER_1; + +# undef AUX778076_ITER_1 +# undef AUX778076_ITER_0 + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/advance_forward.hpp new file mode 100644 index 0000000000..8cfa8ee579 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/advance_forward.hpp @@ -0,0 +1,123 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED +#define BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/advance_forward.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.9 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER advance_forward.hpp +# include + +#else + +# include +# include +# include + +# include +# include +# include + +namespace boost { namespace mpl { namespace aux { + +// forward declaration +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_forward; + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) +# include BOOST_PP_ITERATE() + +// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - BOOST_MPL_LIMIT_UNROLLING) < 0 + ? 0 + : N - BOOST_MPL_LIMIT_UNROLLING + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template<> +struct advance_forward< BOOST_PP_FRAME_ITERATION(1) > +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + +#if i_ > 0 +# define BOOST_PP_ITERATION_PARAMS_2 \ + (3,(1, i_, )) +# include BOOST_PP_ITERATE() +#endif + typedef BOOST_PP_CAT(iter,i_) type; + }; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + /// ETI workaround + template<> struct apply + { + typedef int type; + }; +#endif +}; + +#undef i_ + +///// iteration, depth == 2 + +#elif BOOST_PP_ITERATION_DEPTH() == 2 + +# define AUX778076_ITER_0 BOOST_PP_CAT(iter,BOOST_PP_DEC(BOOST_PP_FRAME_ITERATION(2))) +# define AUX778076_ITER_1 BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(2)) + + typedef typename next::type AUX778076_ITER_1; + +# undef AUX778076_ITER_1 +# undef AUX778076_ITER_0 + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/apply_1st.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/apply_1st.hpp new file mode 100644 index 0000000000..22a5587047 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/apply_1st.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED +#define BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/apply_1st.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include + +namespace boost { namespace mpl { namespace aux { + +struct apply_1st +{ + template< typename Pair, typename T > struct apply + : apply2< + typename Pair::first + , typename Pair::second + , T + > + { + }; +}; + +}}} + +#endif // BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/arg_typedef.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/arg_typedef.hpp new file mode 100644 index 0000000000..04b049173c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/arg_typedef.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED +#define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/arg_typedef.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.3 $ + +#include +#include + +#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + +# define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) typedef T name; + +#else + +# define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) /**/ + +#endif + +#endif // BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/arithmetic_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/arithmetic_op.hpp new file mode 100644 index 0000000000..a1c287a069 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/arithmetic_op.hpp @@ -0,0 +1,92 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/arithmetic_op.hpp,v $ +// $Date: 2004/09/07 08:51:32 $ +// $Revision: 1.4 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +#endif + +#if !defined(AUX778076_OP_PREFIX) +# define AUX778076_OP_PREFIX AUX778076_OP_NAME +#endif + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp +# include + +#else + +# include +# include + + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) +namespace aux { +template< typename T, T n1, T n2 > +struct BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd) +{ + BOOST_STATIC_CONSTANT(T, value = (n1 AUX778076_OP_TOKEN n2)); + typedef integral_c type; +}; +} +#endif + +template<> +struct AUX778076_OP_IMPL_NAME +{ + template< typename N1, typename N2 > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > +#else + : aux::BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type +#endif + { + }; +}; + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#undef AUX778076_OP_TAG_NAME +#undef AUX778076_OP_IMPL_NAME +#undef AUX778076_OP_ARITY +#undef AUX778076_OP_PREFIX +#undef AUX778076_OP_NAME +#undef AUX778076_OP_TOKEN diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp index 45f179e5f8..ba303ae334 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/arity.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/arity_spec.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/arity_spec.hpp new file mode 100644 index 0000000000..3b4fe8c152 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/arity_spec.hpp @@ -0,0 +1,67 @@ + +#ifndef BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED +#define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/arity_spec.hpp,v $ +// $Date: 2004/11/28 02:04:02 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) \ +namespace aux { \ +template< BOOST_MPL_AUX_NTTP_DECL(int, N), BOOST_MPL_PP_PARAMS(i,type T) > \ +struct arity< \ + name< BOOST_MPL_PP_PARAMS(i,T) > \ + , N \ + > \ +{ \ + BOOST_STATIC_CONSTANT(int \ + , value = BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + ); \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) /**/ +#endif + +# define BOOST_MPL_AUX_ARITY_SPEC(i,name) \ + BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,typename,name) \ +/**/ + + +#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ + && !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) \ +namespace aux { \ +template< BOOST_MPL_PP_PARAMS(i,typename T) > \ +struct template_arity< name > \ + : int_ \ +{ \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/ +#endif + + +#endif // BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/at_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/at_impl.hpp new file mode 100644 index 0000000000..a4a1f8f8bb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/at_impl.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/at_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'at_impl' or the primary 'at' template + +template< typename Tag > +struct at_impl +{ + template< typename Sequence, typename N > struct apply + { + typedef typename advance< + typename begin::type + , N + >::type iter_; + + typedef typename deref::type type; + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, at_impl) + +}} + +#endif // BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/back_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/back_impl.hpp new file mode 100644 index 0000000000..b77b231b0c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/back_impl.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/back_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation, requires at least bi-directional iterators; +// conrete sequences might override it by specializing either the +// 'back_impl' or the primary 'back' template + +template< typename Tag > +struct back_impl +{ + template< typename Sequence > struct apply + { + typedef typename end::type end_; + typedef typename prior::type last_; + typedef typename deref::type type; + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, back_impl) + +}} + +#endif // BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/basic_bind.hpp new file mode 100644 index 0000000000..82125ab9e4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/basic_bind.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED +#define BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/basic_bind.hpp,v $ +// $Date: 2004/09/05 09:42:55 $ +// $Revision: 1.1 $ + +#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT +#include + +#endif // BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/begin_end_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/begin_end_impl.hpp new file mode 100644 index 0000000000..3a4437d932 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/begin_end_impl.hpp @@ -0,0 +1,81 @@ + +#ifndef BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/begin_end_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'begin_impl/end_impl' or the primary +// 'begin/end' templates + +template< typename Tag > +struct begin_impl +{ + template< typename Sequence > struct apply + { + typedef typename Sequence::begin type; + }; +}; + +template< typename Tag > +struct end_impl +{ + template< typename Sequence > struct apply + { + typedef typename Sequence::end type; + }; +}; + +// specialize 'begin_trait/end_trait' for two pre-defined tags + +# define AUX778076_IMPL_SPEC(name, tag, result) \ +template<> \ +struct name##_impl \ +{ \ + template< typename Sequence > struct apply \ + { \ + typedef result type; \ + }; \ +}; \ +/**/ + +// a sequence with nested 'begin/end' typedefs; just query them +AUX778076_IMPL_SPEC(begin, nested_begin_end_tag, typename Sequence::begin) +AUX778076_IMPL_SPEC(end, nested_begin_end_tag, typename Sequence::end) + +// if a type 'T' does not contain 'begin/end' or 'tag' members +// and doesn't specialize either 'begin/end' or 'begin_impl/end_impl' +// templates, then we end up here +AUX778076_IMPL_SPEC(begin, non_sequence_tag, void_) +AUX778076_IMPL_SPEC(end, non_sequence_tag, void_) +AUX778076_IMPL_SPEC(begin, na, void_) +AUX778076_IMPL_SPEC(end, na, void_) + +# undef AUX778076_IMPL_SPEC + + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,begin_impl) +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,end_impl) + +}} + +#endif // BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/clear_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/clear_impl.hpp new file mode 100644 index 0000000000..5bcc4cb9a7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/clear_impl.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/clear_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.6 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +// no default implementation; the definition is needed to make MSVC happy + +template< typename Tag > +struct clear_impl +{ + template< typename Sequence > struct apply; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, clear_impl) + +}} + +#endif // BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/common_name_wknd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/common_name_wknd.hpp new file mode 100644 index 0000000000..d7a254d607 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/common_name_wknd.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED +#define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/common_name_wknd.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include + +#if BOOST_WORKAROUND(__BORLANDC__, < 0x561) +// agurt, 12/nov/02: to suppress the bogus "Cannot have both a template class +// and function named 'xxx'" diagnostic +# define BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ +namespace name_##wknd { \ +template< typename > void name(); \ +} \ +/**/ + +#else + +# define BOOST_MPL_AUX_COMMON_NAME_WKND(name) /**/ + +#endif // __BORLANDC__ + +#endif // BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/comparison_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/comparison_op.hpp new file mode 100644 index 0000000000..2ca3b85901 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/comparison_op.hpp @@ -0,0 +1,83 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/comparison_op.hpp,v $ +// $Date: 2004/09/07 08:51:32 $ +// $Revision: 1.4 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#if !defined(AUX778076_OP_PREFIX) +# define AUX778076_OP_PREFIX AUX778076_OP_NAME +#endif + +#define AUX778076_OP_ARITY 2 + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp +# include + +#else + +# include +# include + +namespace boost { namespace mpl { + +// MSVC workaround: implement less in terms of greater +#if 0 AUX778076_OP_TOKEN 1 && !(1 AUX778076_OP_TOKEN 0) && !(0 AUX778076_OP_TOKEN 0) +# define AUX778076_OP(N1, N2) \ + ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) \ +/**/ +#else +# define AUX778076_OP(N1, N2) \ + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value \ + AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value \ + ) \ +/**/ +#endif + +template<> +struct AUX778076_OP_IMPL_NAME +{ + template< typename N1, typename N2 > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) + : bool_< AUX778076_OP(N1, N2) > + { +#else + { + BOOST_STATIC_CONSTANT(bool, value = AUX778076_OP(N1, N2)); + typedef bool_ type; +#endif + }; +}; + +#undef AUX778076_OP + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#undef AUX778076_OP_TAG_NAME +#undef AUX778076_OP_IMPL_NAME +#undef AUX778076_OP_ARITY +#undef AUX778076_OP_PREFIX +#undef AUX778076_OP_NAME +#undef AUX778076_OP_TOKEN diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/adl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/adl.hpp index c804d8578e..2e0c9db53e 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/adl.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/adl.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/adl.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/arrays.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/arrays.hpp new file mode 100644 index 0000000000..d8a07ca6c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/arrays.hpp @@ -0,0 +1,30 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/arrays.hpp,v $ +// $Date: 2004/09/03 15:56:55 $ +// $Revision: 1.3 $ + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ + || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + ) + +# define BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/bind.hpp new file mode 100644 index 0000000000..0739f7ce89 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/bind.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED + +// Copyright David Abrahams 2002 +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/bind.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.6 $ + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ + ) + +# define BOOST_MPL_CFG_NO_BIND_TEMPLATE + +#endif + +//#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT + +#endif // BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/compiler.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/compiler.hpp new file mode 100644 index 0000000000..cc184e3de1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/compiler.hpp @@ -0,0 +1,64 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/compiler.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.9 $ + +#if !defined(BOOST_MPL_CFG_COMPILER_DIR) + +# include +# include +# include +# include +# include +# include + +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# define BOOST_MPL_CFG_COMPILER_DIR msvc60 + +# elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) +# define BOOST_MPL_CFG_COMPILER_DIR msvc70 + +# elif BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) +# define BOOST_MPL_CFG_COMPILER_DIR gcc + +# elif BOOST_WORKAROUND(__BORLANDC__, < 0x600) +# if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_CFG_COMPILER_DIR bcc551 +# else +# define BOOST_MPL_CFG_COMPILER_DIR bcc +# endif + +# elif BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_MPL_CFG_COMPILER_DIR dmc + +# elif defined(__MWERKS__) +# if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_CFG_COMPILER_DIR mwcw +# else +# define BOOST_MPL_CFG_COMPILER_DIR plain +# endif + +# elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# define BOOST_MPL_CFG_COMPILER_DIR no_ctps + +# elif defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) +# define BOOST_MPL_CFG_COMPILER_DIR no_ttp + +# else +# define BOOST_MPL_CFG_COMPILER_DIR plain +# endif + +#endif // BOOST_MPL_CFG_COMPILER_DIR + +#endif // BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/ctps.hpp index b03657d032..682504d297 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/ctps.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/ctps.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/ctps.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/dependent_nttp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dependent_nttp.hpp new file mode 100644 index 0000000000..3bdbb932b4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dependent_nttp.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/dependent_nttp.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.7 $ + +#include +#include + +// GCC and EDG-based compilers incorrectly reject the following code: +// template< typename T, T n > struct a; +// template< typename T > struct b; +// template< typename T, T n > struct b< a > {}; + +#if !defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(300)) \ + || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ + ) + +# define BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp new file mode 100644 index 0000000000..d5960f823e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.2 $ + +#include + +#if !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + +# define BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp index 568bef64ba..dc4c71591c 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/dtp.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp index 8166f89f4e..39b014c026 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/eti.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/forwarding.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/forwarding.hpp new file mode 100644 index 0000000000..9f1f514905 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/forwarding.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/forwarding.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.2 $ + +#include + +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(__BORLANDC__, < 0x600) + +# define BOOST_MPL_CFG_NO_NESTED_FORWARDING + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/gcc.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/gcc.hpp index 0ec5319646..080d91ae2a 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/gcc.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/gcc.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/gcc.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/has_apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/has_apply.hpp new file mode 100644 index 0000000000..a24867cba6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/has_apply.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/has_apply.hpp,v $ +// $Date: 2004/09/13 06:10:10 $ +// $Revision: 1.2 $ + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) \ + && ( defined(BOOST_MPL_CFG_NO_HAS_XXX) \ + || BOOST_WORKAROUND(__EDG_VERSION__, < 300) \ + || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ + ) + +# define BOOST_MPL_CFG_NO_HAS_APPLY + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/has_xxx.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/has_xxx.hpp new file mode 100644 index 0000000000..7dc14ea5d7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/has_xxx.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// Copyright David Abrahams 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/has_xxx.hpp,v $ +// $Date: 2004/09/03 15:56:56 $ +// $Revision: 1.3 $ + +#include +#include + +// agurt, 11/jan/03: signals a stub-only 'has_xxx' implementation + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) \ + && ( defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ + || BOOST_WORKAROUND(__GNUC__, <= 2) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ + ) + +# define BOOST_MPL_CFG_NO_HAS_XXX + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/integral.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/integral.hpp index bfaafcaf89..2c96daa28f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/integral.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/integral.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/integral.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/intel.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/intel.hpp index 93702d4206..a054f8c57b 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/intel.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/intel.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/intel.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp index 604afe9ec9..e2227789c4 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/lambda.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp index 5dc63bc656..e0e8cc21b9 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/msvc.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc_typename.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc_typename.hpp new file mode 100644 index 0000000000..5707148722 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc_typename.hpp @@ -0,0 +1,26 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/msvc_typename.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.4 $ + +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_MSVC_TYPENAME +#else +# define BOOST_MSVC_TYPENAME typename +#endif + +#endif // BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp index d273d63c08..f4c9227d50 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/nttp.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/operators.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/operators.hpp new file mode 100644 index 0000000000..7383dd4018 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/operators.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/operators.hpp,v $ +// $Date: 2005/06/14 12:42:08 $ +// $Revision: 1.4 $ + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) \ + && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__BORLANDC__, <= 0x600) \ + || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) \ + || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, <= 0x0295) \ + || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \ + ) + +# define BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp index a7618ab797..aefde52f92 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/overload_resolution.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp index 0acd76ee86..6845e87614 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/preprocessor.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp index 43a7ffb107..b44587e9af 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/static_constant.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp index 88c38d6410..f3dd40e77a 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/ttp.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/typeof.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/typeof.hpp new file mode 100644 index 0000000000..14a513ee8e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/typeof.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/typeof.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.2 $ + +#include + +#if !defined(BOOST_MPL_CFG_HAS_TYPEOF) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( defined(BOOST_MPL_CFG_GCC) && BOOST_MPL_CFG_GCC >= 0x0302 \ + || defined(__MWERKS__) && __MWERKS__ >= 0x3000 \ + ) + +# define BOOST_MPL_CFG_HAS_TYPEOF + +#endif + + +#if !defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && defined(BOOST_MPL_CFG_HAS_TYPEOF) + +# define BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/use_preprocessed.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/use_preprocessed.hpp new file mode 100644 index 0000000000..6548ac6817 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/use_preprocessed.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/use_preprocessed.hpp,v $ +// $Date: 2004/09/02 15:40:45 $ +// $Revision: 1.7 $ + +// #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp index 0e64dc74c3..90a268899b 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/config/workaround.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/contains_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/contains_impl.hpp new file mode 100644 index 0000000000..73e1b27349 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/contains_impl.hpp @@ -0,0 +1,61 @@ + +#ifndef BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED + +// Copyright Eric Friedman 2002 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/contains_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +template< typename Tag > +struct contains_impl +{ + template< typename Sequence, typename T > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : not_< is_same< + typename find::type + , typename end::type + > > + { +#else + { + typedef not_< is_same< + typename find::type + , typename end::type + > > type; + + BOOST_STATIC_CONSTANT(bool, value = + (not_< is_same< + typename find::type + , typename end::type + > >::value) + ); +#endif + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,contains_impl) + +}} + +#endif // BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/count_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/count_args.hpp new file mode 100644 index 0000000000..14e7d0ec79 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/count_args.hpp @@ -0,0 +1,105 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/count_args.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.5 $ + +#include +#include +#include + +#if !defined(AUX778076_COUNT_ARGS_PARAM_NAME) +# define AUX778076_COUNT_ARGS_PARAM_NAME T +#endif + +#if !defined(AUX778076_COUNT_ARGS_TEMPLATE_PARAM) +# define AUX778076_COUNT_ARGS_TEMPLATE_PARAM typename AUX778076_COUNT_ARGS_PARAM_NAME +#endif + +// local macros, #undef-ined at the end of the header + +#if !defined(AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES) + +# include +# include + +# define AUX778076_COUNT_ARGS_REPEAT BOOST_MPL_PP_REPEAT +# define AUX778076_COUNT_ARGS_PARAMS(param) \ + BOOST_MPL_PP_PARAMS( \ + AUX778076_COUNT_ARGS_ARITY \ + , param \ + ) \ + /**/ + +#else + +# include +# include +# include + +# define AUX778076_COUNT_ARGS_REPEAT BOOST_PP_REPEAT +# define AUX778076_COUNT_ARGS_PARAMS(param) \ + BOOST_PP_ENUM_SHIFTED_PARAMS( \ + BOOST_PP_INC(AUX778076_COUNT_ARGS_ARITY) \ + , param \ + ) \ + /**/ + +#endif // AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES + + +#define AUX778076_IS_ARG_TEMPLATE_NAME \ + BOOST_PP_CAT(is_,BOOST_PP_CAT(AUX778076_COUNT_ARGS_PREFIX,_arg)) \ +/**/ + +#define AUX778076_COUNT_ARGS_FUNC(unused, i, param) \ + BOOST_PP_EXPR_IF(i, +) \ + AUX778076_IS_ARG_TEMPLATE_NAME::value \ +/**/ + +// is__arg +template< AUX778076_COUNT_ARGS_TEMPLATE_PARAM > +struct AUX778076_IS_ARG_TEMPLATE_NAME +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct AUX778076_IS_ARG_TEMPLATE_NAME +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +// _count_args +template< + AUX778076_COUNT_ARGS_PARAMS(AUX778076_COUNT_ARGS_TEMPLATE_PARAM) + > +struct BOOST_PP_CAT(AUX778076_COUNT_ARGS_PREFIX,_count_args) +{ + BOOST_STATIC_CONSTANT(int, value = AUX778076_COUNT_ARGS_REPEAT( + AUX778076_COUNT_ARGS_ARITY + , AUX778076_COUNT_ARGS_FUNC + , AUX778076_COUNT_ARGS_PARAM_NAME + )); +}; + +#undef AUX778076_COUNT_ARGS_FUNC +#undef AUX778076_IS_ARG_TEMPLATE_NAME +#undef AUX778076_COUNT_ARGS_PARAMS +#undef AUX778076_COUNT_ARGS_REPEAT + +#undef AUX778076_COUNT_ARGS_ARITY +#undef AUX778076_COUNT_ARGS_DEFAULT +#undef AUX778076_COUNT_ARGS_PREFIX +#undef AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES +#undef AUX778076_COUNT_ARGS_TEMPLATE_PARAM +#undef AUX778076_COUNT_ARGS_PARAM_NAME diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/count_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/count_impl.hpp new file mode 100644 index 0000000000..f1f10bc350 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/count_impl.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/count_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Tag > struct count_impl +{ + template< typename Sequence, typename T > struct apply +#if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x561)) + { + typedef typename count_if< Sequence,same_as >::type type; + BOOST_STATIC_CONSTANT(int, value = BOOST_MPL_AUX_VALUE_WKND(type)::value); +#else + : count_if< Sequence,same_as > + { +#endif + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,count_impl) + +}} + +#endif // BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/empty_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/empty_impl.hpp new file mode 100644 index 0000000000..a49423cbe0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/empty_impl.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/empty_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'empty_impl' or the primary 'empty' template + +template< typename Tag > +struct empty_impl +{ + template< typename Sequence > struct apply + : is_same< + typename begin::type + , typename end::type + > + { + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,empty_impl) + +}} + +#endif // BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/erase_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/erase_impl.hpp new file mode 100644 index 0000000000..1652344911 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/erase_impl.hpp @@ -0,0 +1,69 @@ + +#ifndef BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/erase_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'erase_impl' or the primary 'erase' template + +template< typename Tag > +struct erase_impl +{ + template< + typename Sequence + , typename First + , typename Last + > + struct apply + { + typedef typename if_na< Last,typename next::type >::type last_; + + // 1st half: [begin, first) + typedef iterator_range< + typename begin::type + , First + > first_half_; + + // 2nd half: [last, end) ... that is, [last + 1, end) + typedef iterator_range< + last_ + , typename end::type + > second_half_; + + typedef typename reverse_fold< + second_half_ + , typename clear::type + , push_front<_,_> + >::type half_sequence_; + + typedef typename reverse_fold< + first_half_ + , half_sequence_ + , push_front<_,_> + >::type type; + }; +}; + +}} + +#endif // BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/erase_key_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/erase_key_impl.hpp new file mode 100644 index 0000000000..58218a6304 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/erase_key_impl.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/erase_key_impl.hpp,v $ +// $Date: 2004/09/05 09:42:55 $ +// $Revision: 1.3 $ + +#include +#include + +namespace boost { namespace mpl { + +template< typename Tag > +struct erase_key_impl +{ + template< typename Sequence, typename Key > struct apply; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, erase_key_impl) + +}} + +#endif // BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/filter_iter.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/filter_iter.hpp new file mode 100644 index 0000000000..3bf806dff3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/filter_iter.hpp @@ -0,0 +1,140 @@ + +#ifndef BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED +#define BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/filter_iter.hpp,v $ +// $Date: 2004/09/07 12:07:56 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Iterator + , typename LastIterator + , typename Predicate + > +struct filter_iter; + +template< + typename Iterator + , typename LastIterator + , typename Predicate + > +struct next_filter_iter +{ + typedef typename find_if< + iterator_range + , Predicate + >::type base_iter_; + + typedef filter_iter type; +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename Iterator + , typename LastIterator + , typename Predicate + > +struct filter_iter +{ + typedef Iterator base; + typedef forward_iterator_tag category; + typedef typename aux::next_filter_iter< + typename mpl::next::type + , LastIterator + , Predicate + >::type next; + + typedef typename deref::type type; +}; + +template< + typename LastIterator + , typename Predicate + > +struct filter_iter< LastIterator,LastIterator,Predicate > +{ + typedef LastIterator base; + typedef forward_iterator_tag category; +}; + +#else + +template< bool > +struct filter_iter_impl +{ + template< + typename Iterator + , typename LastIterator + , typename Predicate + > + struct result_ + { + typedef Iterator base; + typedef forward_iterator_tag category; + typedef typename next_filter_iter< + typename mpl::next::type + , LastIterator + , Predicate + >::type next; + + typedef typename deref::type type; + }; +}; + +template<> +struct filter_iter_impl< true > +{ + template< + typename Iterator + , typename LastIterator + , typename Predicate + > + struct result_ + { + typedef Iterator base; + typedef forward_iterator_tag category; + }; +}; + +template< + typename Iterator + , typename LastIterator + , typename Predicate + > +struct filter_iter + : filter_iter_impl< + ::boost::is_same::value + >::template result_< Iterator,LastIterator,Predicate > +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace aux + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::filter_iter) + +}} + +#endif // BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/find_if_pred.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/find_if_pred.hpp new file mode 100644 index 0000000000..c07d89d6c7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/find_if_pred.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED +#define BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Eric Friedman 2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename Predicate > +struct find_if_pred +{ + template< typename Iterator > + struct apply + { + typedef not_< aux::iter_apply1 > type; + }; +}; + +}}} + +#endif // BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_impl.hpp new file mode 100644 index 0000000000..0b56671479 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_impl.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/fold_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# include +# include +# endif +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER fold_impl.hpp +# include + +#else + +# define AUX778076_FOLD_IMPL_OP(iter) typename deref::type +# define AUX778076_FOLD_IMPL_NAME_PREFIX fold +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/fold_impl_body.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_impl_body.hpp new file mode 100644 index 0000000000..e006189054 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_impl_body.hpp @@ -0,0 +1,365 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if !defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/fold_impl_body.hpp,v $ +// $Date: 2004/10/24 08:18:03 $ +// $Revision: 1.8 $ + +# include +# include +# include +# include +# include +# include + +# include +# include +# include + +// local macros, #undef-ined at the end of the header + +# define AUX778076_ITER_FOLD_STEP(unused, i, unused2) \ + typedef typename apply2< \ + ForwardOp \ + , BOOST_PP_CAT(state,i) \ + , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,i)) \ + >::type BOOST_PP_CAT(state,BOOST_PP_INC(i)); \ + typedef typename mpl::next::type \ + BOOST_PP_CAT(iter,BOOST_PP_INC(i)); \ + /**/ + +# define AUX778076_FOLD_IMPL_NAME \ + BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \ + /**/ + +# define AUX778076_FOLD_CHUNK_NAME \ + BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \ + /**/ + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration +template< + BOOST_MPL_AUX_NTTP_DECL(int, N) + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) +# include BOOST_PP_ITERATE() + +// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING +template< + BOOST_MPL_AUX_NTTP_DECL(int, N) + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME +{ + typedef AUX778076_FOLD_IMPL_NAME< + BOOST_MPL_LIMIT_UNROLLING + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef AUX778076_FOLD_IMPL_NAME< + ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +// fallback implementation for sequences of unknown size +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp> + : AUX778076_FOLD_IMPL_NAME< + -1 + , typename mpl::next::type + , Last + , typename apply2::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp> +{ + typedef State state; + typedef Last iterator; +}; + +# else // BOOST_WORKAROUND(__BORLANDC__, < 0x600) + +// Borland have some serious problems with the unrolled version, so +// we always use a basic implementation +template< + BOOST_MPL_AUX_NTTP_DECL(int, N) + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME +{ + typedef AUX778076_FOLD_IMPL_NAME< + -1 + , typename mpl::next::type + , Last + , typename apply2::type + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + typedef state type; +}; + +template< + BOOST_MPL_AUX_NTTP_DECL(int, N) + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME +{ + typedef State state; + typedef Last iterator; + typedef state type; +}; + +# endif // BOOST_WORKAROUND(__BORLANDC__, < 0x600) + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct AUX778076_FOLD_CHUNK_NAME; + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) +# include BOOST_PP_ITERATE() + +// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct AUX778076_FOLD_CHUNK_NAME +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef AUX778076_FOLD_IMPL_NAME< + BOOST_MPL_LIMIT_UNROLLING + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef AUX778076_FOLD_IMPL_NAME< + ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +// fallback implementation for sequences of unknown size +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step); + +template< + typename Last + , typename State + > +struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct AUX778076_FOLD_CHUNK_NAME<-1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same::type + , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) + , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + /// ETI workaround + template<> struct result_ + { + typedef int state; + typedef int iterator; + }; +#endif +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) +{ + // can't inherit here - it breaks MSVC 7.0 + typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_< + typename mpl::next::type + , Last + , typename apply2::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + BOOST_MPL_AUX_NTTP_DECL(int, N) + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME + : AUX778076_FOLD_CHUNK_NAME + ::template result_ +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +}}} + +# undef AUX778076_FOLD_IMPL_NAME +# undef AUX778076_FOLD_CHUNK_NAME +# undef AUX778076_ITER_FOLD_STEP + +#undef AUX778076_FOLD_IMPL_OP +#undef AUX778076_FOLD_IMPL_NAME_PREFIX + +///// iteration + +#else + +# define n_ BOOST_PP_FRAME_ITERATION(1) + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME +{ + typedef First iter0; + typedef State state0; + + BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused) + + typedef BOOST_PP_CAT(state,n_) state; + typedef BOOST_PP_CAT(iter,n_) iterator; +}; + +#else + +template<> struct AUX778076_FOLD_CHUNK_NAME +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + + BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused) + + typedef BOOST_PP_CAT(state,n_) state; + typedef BOOST_PP_CAT(iter,n_) iterator; + }; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + /// ETI workaround + template<> struct result_ + { + typedef int state; + typedef int iterator; + }; +#endif +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +# undef n_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/fold_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_op.hpp new file mode 100644 index 0000000000..fbe20d7c9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_op.hpp @@ -0,0 +1,37 @@ + +#ifndef BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED +#define BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/fold_op.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include + +namespace boost { namespace mpl { namespace aux { + +// hand-written version is more efficient than bind/lambda expression +template< typename Op > +struct fold_op +{ + template< typename T1, typename T2 > struct apply + { + typedef typename apply2< + Op + , T1 + , typename T2::type + >::type type; + }; +}; + +}}} + +#endif // BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/fold_pred.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_pred.hpp new file mode 100644 index 0000000000..e3a193feb1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/fold_pred.hpp @@ -0,0 +1,37 @@ + +#ifndef BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED +#define BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/fold_pred.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename Last > +struct fold_pred +{ + template< + typename State + , typename Iterator + > + struct apply + : not_same_as::template apply + { + }; +}; + +}}} + +#endif // BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/front_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/front_impl.hpp new file mode 100644 index 0000000000..07288d865a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/front_impl.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/front_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'front_impl' or the primary 'front' template + +template< typename Tag > +struct front_impl +{ + template< typename Sequence > struct apply + { + typedef typename begin::type iter_; + typedef typename deref::type type; + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,front_impl) + +}} + +#endif // BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/full_lambda.hpp new file mode 100644 index 0000000000..88ba9e56f3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/full_lambda.hpp @@ -0,0 +1,350 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED +#define BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/full_lambda.hpp,v $ +// $Date: 2004/09/04 01:10:19 $ +// $Revision: 1.14 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# include +# endif +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER full_lambda.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_LAMBDA_PARAMS(i_, param) \ + BOOST_MPL_PP_PARAMS(i_, param) \ + /**/ + +# define AUX778076_BIND_PARAMS(param) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ + +# define AUX778076_BIND_N_PARAMS(i_, param) \ + BOOST_PP_COMMA_IF(i_) \ + BOOST_MPL_PP_PARAMS(i_, param) \ + /**/ + +# define AUX778076_ARITY_PARAM(param) \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) \ + /**/ + + +#define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY +namespace aux { + +template< + BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false) + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) > + : false_ +{ +}; + +} // namespace aux +#undef n_ + +template< + typename T + , typename Tag + AUX778076_ARITY_PARAM(typename Arity) + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + + +template< int N, typename Tag > +struct lambda< arg,Tag AUX778076_ARITY_PARAM(int_<-1>) > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect,Tag AUX778076_ARITY_PARAM(int_<1>) > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form +template< + typename F, AUX778076_BIND_PARAMS(typename T) + , typename Tag + > +struct lambda< + bind + , Tag + AUX778076_ARITY_PARAM(int_) + > +{ + typedef false_ is_le; + typedef bind result_; + typedef result_ type; +}; + + +#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) + +template< + typename F + , typename Tag1 + , typename Tag2 + , typename Arity + > +struct lambda< + lambda + , Tag2 + , int_<3> + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + + typedef typename l1::is_le is_le; + typedef bind1< quote1, typename l1::result_ > arity_; + typedef lambda< typename if_::type,Tag2 > l3; + + typedef aux::le_result3 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +#elif !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +#endif + +# undef AUX778076_ARITY_PARAM +# undef AUX778076_BIND_N_PARAMS +# undef AUX778076_BIND_PARAMS +# undef AUX778076_LAMBDA_PARAMS + +#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +BOOST_MPL_AUX_NA_SPEC(2, lambda) +#else +BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) +#endif + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 +#define i_ BOOST_PP_FRAME_ITERATION(1) + +#if i_ > 0 + +namespace aux { + +# define AUX778076_RESULT(unused, i_, T) \ + BOOST_PP_COMMA_IF(i_) \ + typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::result_ \ + /**/ + +# define AUX778076_TYPE(unused, i_, T) \ + BOOST_PP_COMMA_IF(i_) \ + typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::type \ + /**/ + +template< + typename IsLE, typename Tag + , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F + , AUX778076_LAMBDA_PARAMS(i_, typename L) + > +struct BOOST_PP_CAT(le_result,i_) +{ + typedef F< + BOOST_MPL_PP_REPEAT(i_, AUX778076_TYPE, L) + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F + , AUX778076_LAMBDA_PARAMS(i_, typename L) + > +struct BOOST_PP_CAT(le_result,i_)< true_,Tag,F,AUX778076_LAMBDA_PARAMS(i_, L) > +{ + typedef BOOST_PP_CAT(bind,i_)< + BOOST_PP_CAT(quote,i_) + , BOOST_MPL_PP_REPEAT(i_, AUX778076_RESULT, L) + > result_; + + typedef mpl::protect type; +}; + +# undef AUX778076_TYPE +# undef AUX778076_RESULT + +} // namespace aux + + +# define AUX778076_LAMBDA_TYPEDEF(unused, i_, T) \ + typedef lambda< BOOST_PP_CAT(T, BOOST_PP_INC(i_)), Tag > \ + BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \ +/**/ + +# define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \ + typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \ + BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \ +/**/ + +# define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \ + BOOST_PP_COMMA_IF(i_) \ + BOOST_PP_CAT(is_le,BOOST_PP_INC(i_))::value \ +/**/ + +template< + template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F + , AUX778076_LAMBDA_PARAMS(i_, typename T) + , typename Tag + > +struct lambda< + F + , Tag + AUX778076_ARITY_PARAM(int_) + > +{ + BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, T) + BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused) + + typedef typename aux::lambda_or< + BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused) + >::type is_le; + + typedef aux::BOOST_PP_CAT(le_result,i_)< + is_le, Tag, F, AUX778076_LAMBDA_PARAMS(i_, l) + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + + +# undef AUX778076_IS_LAMBDA_EXPR +# undef AUX778076_IS_LE_TYPEDEF +# undef AUX778076_LAMBDA_TYPEDEF + +#endif // i_ > 0 + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) + , typename Tag + > +struct lambda< + BOOST_PP_CAT(bind,i_) + , Tag + AUX778076_ARITY_PARAM(int_) + > +{ + typedef false_ is_le; + typedef BOOST_PP_CAT(bind,i_)< + F + AUX778076_BIND_N_PARAMS(i_, T) + > result_; + + typedef result_ type; +}; + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_apply.hpp new file mode 100644 index 0000000000..8d0d0051be --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_apply.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_apply.hpp,v $ +// $Date: 2004/09/03 15:56:55 $ +// $Revision: 1.1 $ + +#include +#include + +namespace boost { namespace mpl { namespace aux { +#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false) +#else +template< typename T, typename fallback_ = false_ > +struct has_apply + : fallback_ +{ +}; +#endif +}}} + +#endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_begin.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_begin.hpp new file mode 100644 index 0000000000..1211903b51 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_begin.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_begin.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.3 $ + +#include + +namespace boost { namespace mpl { namespace aux { +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_begin, begin, true) +}}} + +#endif // BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_key_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_key_impl.hpp new file mode 100644 index 0000000000..0b3e8f28f8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_key_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// Copyright David Abrahams 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_key_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.3 $ + +#include +#include + +namespace boost { namespace mpl { + +// no default implementation; the definition is needed to make MSVC happy + +template< typename Tag > struct has_key_impl +{ + template< typename AssociativeSequence, typename Key > struct apply; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,has_key_impl) + +}} + +#endif // BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_rebind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_rebind.hpp new file mode 100644 index 0000000000..5f9b83262e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_rebind.hpp @@ -0,0 +1,99 @@ + +#ifndef BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_rebind.hpp,v $ +// $Date: 2004/11/28 01:33:58 $ +// $Revision: 1.13 $ + +#include +#include +#include + +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) +# include +#elif BOOST_WORKAROUND(BOOST_MSVC, <= 1200) +# include +# include +# include +# include +#elif BOOST_WORKAROUND(__BORLANDC__, < 0x600) +# include +# include +# include +# include +# include +#else +# include +# include +# include +#endif + +namespace boost { namespace mpl { namespace aux { + +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) + +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_rebind, rebind, false) + +#elif BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_rebind_impl, rebind, false) + +template< typename T > +struct has_rebind + : if_< + msvc_is_class + , has_rebind_impl + , bool_ + >::type +{ +}; + +#else // the rest + +template< typename T > struct has_rebind_tag {}; +no_tag operator|(has_rebind_tag, void const volatile*); + +# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) +template< typename T > +struct has_rebind +{ + static has_rebind_tag* get(); + BOOST_STATIC_CONSTANT(bool, value = + sizeof(has_rebind_tag() | get()) == sizeof(yes_tag) + ); +}; +# else // __BORLANDC__ +template< typename T > +struct has_rebind_impl +{ + static T* get(); + BOOST_STATIC_CONSTANT(bool, value = + sizeof(has_rebind_tag() | get()) == sizeof(yes_tag) + ); +}; + +template< typename T > +struct has_rebind + : if_< + is_class + , has_rebind_impl + , bool_ + >::type +{ +}; +# endif // __BORLANDC__ + +#endif + +}}} + +#endif // BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_size.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_size.hpp new file mode 100644 index 0000000000..9a8806a376 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_size.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_size.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.6 $ + +#include + +namespace boost { namespace mpl { namespace aux { +BOOST_MPL_HAS_XXX_TRAIT_DEF(size) +}}} + +#endif // BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_tag.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_tag.hpp new file mode 100644 index 0000000000..9e25244ef3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_tag.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_tag.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.3 $ + +#include + +namespace boost { namespace mpl { namespace aux { +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_tag, tag, false) +}}} + +#endif // BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/has_type.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/has_type.hpp new file mode 100644 index 0000000000..b89311a4ff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/has_type.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/has_type.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include + +namespace boost { namespace mpl { namespace aux { +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_type, type, true) +}}} + +#endif // BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/include_preprocessed.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/include_preprocessed.hpp new file mode 100644 index 0000000000..fd33f3965b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/include_preprocessed.hpp @@ -0,0 +1,34 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/include_preprocessed.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX_PREPROCESSED_HEADER \ + BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#else +# define AUX_PREPROCESSED_HEADER \ + BOOST_PP_CAT(BOOST_MPL_CFG_COMPILER_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX_PREPROCESSED_HEADER) +# undef AUX_PREPROCESSED_HEADER + +#undef BOOST_MPL_PREPROCESSED_HEADER diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/insert_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/insert_impl.hpp new file mode 100644 index 0000000000..edea0a299b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/insert_impl.hpp @@ -0,0 +1,68 @@ + +#ifndef BOOST_MPL_INSERT_IMPL_HPP_INCLUDED +#define BOOST_MPL_INSERT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/insert_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'insert_impl' or the primary 'insert' template + +template< typename Tag > +struct insert_impl +{ + template< + typename Sequence + , typename Pos + , typename T + > + struct apply + { + typedef iterator_range< + typename begin::type + , Pos + > first_half_; + + typedef iterator_range< + Pos + , typename end::type + > second_half_; + + typedef typename reverse_fold< + second_half_ + , typename clear::type + , push_front<_,_> + >::type half_sequence_; + + typedef typename reverse_fold< + first_half_ + , typename push_front::type + , push_front<_,_> + >::type type; + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_impl) + +}} + +#endif // BOOST_MPL_INSERT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/insert_range_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/insert_range_impl.hpp new file mode 100644 index 0000000000..8cef7ce85b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/insert_range_impl.hpp @@ -0,0 +1,77 @@ + +#ifndef BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/insert_range_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'insert_range_impl' or the primary +// 'insert_range' template + + +template< typename Tag > +struct insert_range_impl +{ + template< + typename Sequence + , typename Pos + , typename Range + > + struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : reverse_copy< + joint_view< + iterator_range::type,Pos> + , joint_view< + Range + , iterator_range::type> + > + > + , front_inserter< typename clear::type > + > + { +#else + { + typedef typename reverse_copy< + joint_view< + iterator_range::type,Pos> + , joint_view< + Range + , iterator_range::type> + > + > + , front_inserter< typename clear::type > + >::type type; +#endif + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_range_impl) + +}} + +#endif // BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/inserter_algorithm.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/inserter_algorithm.hpp new file mode 100644 index 0000000000..e6215d08b0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/inserter_algorithm.hpp @@ -0,0 +1,159 @@ + +#ifndef BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED +#define BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/inserter_algorithm.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +# define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity, name) \ +BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ +template< \ + BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ + > \ +struct name \ + : aux::name##_impl \ +{ \ +}; \ +\ +template< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ + > \ +struct name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > \ + : if_< has_push_back \ + , aux::name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , back_inserter< typename clear::type > \ + > \ + , aux::reverse_##name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , front_inserter< typename clear::type > \ + > \ + >::type \ +{ \ +}; \ +\ +template< \ + BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ + > \ +struct reverse_##name \ + : aux::reverse_##name##_impl \ +{ \ +}; \ +\ +template< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ + > \ +struct reverse_##name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > \ + : if_< has_push_back \ + , aux::reverse_##name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , back_inserter< typename clear::type > \ + > \ + , aux::name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , front_inserter< typename clear::type > \ + > \ + >::type \ +{ \ +}; \ +BOOST_MPL_AUX_NA_SPEC(arity, name) \ +BOOST_MPL_AUX_NA_SPEC(arity, reverse_##name) \ +/**/ + +#else + +# define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity, name) \ +BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ +template< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ + > \ +struct def_##name##_impl \ + : if_< has_push_back \ + , aux::name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , back_inserter< typename clear::type > \ + > \ + , aux::reverse_##name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , front_inserter< typename clear::type > \ + > \ + >::type \ +{ \ +}; \ +\ +template< \ + BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ + > \ +struct name \ +{ \ + typedef typename eval_if< \ + is_na \ + , def_##name##_impl \ + , aux::name##_impl \ + >::type type; \ +}; \ +\ +template< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ + > \ +struct def_reverse_##name##_impl \ + : if_< has_push_back \ + , aux::reverse_##name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , back_inserter< typename clear::type > \ + > \ + , aux::name##_impl< \ + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ + , front_inserter< typename clear::type > \ + > \ + >::type \ +{ \ +}; \ +template< \ + BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ + > \ +struct reverse_##name \ +{ \ + typedef typename eval_if< \ + is_na \ + , def_reverse_##name##_impl \ + , aux::reverse_##name##_impl \ + >::type type; \ +}; \ +BOOST_MPL_AUX_NA_SPEC(arity, name) \ +BOOST_MPL_AUX_NA_SPEC(arity, reverse_##name) \ +/**/ + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp index fb381629e9..3743b39154 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp @@ -7,7 +7,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/integral_wrapper.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp new file mode 100644 index 0000000000..751aeaff9d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp @@ -0,0 +1,64 @@ + +#ifndef BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED +#define BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/is_msvc_eti_arg.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include +#include + +namespace boost { namespace mpl { namespace aux { + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + +template< typename T > +struct is_msvc_eti_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#else // BOOST_MPL_CFG_MSVC_60_ETI_BUG + +struct eti_int_convertible +{ + eti_int_convertible(int); +}; + +template< typename T > +struct is_msvc_eti_arg +{ + static no_tag test(...); + static yes_tag test(eti_int_convertible); + static T& get(); + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(test(get())) == sizeof(yes_tag) + ); +}; + +#endif + +template<> +struct is_msvc_eti_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +#endif // BOOST_MPL_CFG_MSVC_ETI_BUG + +}}} + +#endif // BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/iter_apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_apply.hpp new file mode 100644 index 0000000000..04bca019e2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_apply.hpp @@ -0,0 +1,47 @@ + +#ifndef BOOST_MPL_ITER_APPLY_HPP_INCLUDED +#define BOOST_MPL_ITER_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/iter_apply.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< + typename F + , typename Iterator + > +struct iter_apply1 + : apply1< F,typename deref::type > +{ +}; + +template< + typename F + , typename Iterator1 + , typename Iterator2 + > +struct iter_apply2 + : apply2< + F + , typename deref::type + , typename deref::type + > +{ +}; + +}}} + +#endif // BOOST_MPL_ITER_APPLY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..bc4f826d11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp @@ -0,0 +1,210 @@ + +#ifndef BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/iter_fold_if_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.8 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER iter_fold_if_impl.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +// agurt, 25/jun/02: MSVC 6.5 workaround, had to get rid of inheritance +// here and in 'iter_fold_if_backward_step', because sometimes it interfered +// with the "early template instantiation bug" in _really_ ugly ways +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp,mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp,identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + + +// local macros, #undef-ined at the end of the header + +# define AUX_ITER_FOLD_FORWARD_STEP(unused, i, unused2) \ + typedef iter_fold_if_forward_step< \ + typename BOOST_PP_CAT(forward_step,i)::iterator \ + , typename BOOST_PP_CAT(forward_step,i)::state \ + , ForwardOp \ + , ForwardPredicate \ + > BOOST_PP_CAT(forward_step, BOOST_PP_INC(i)); \ + /**/ + +# define AUX_ITER_FOLD_BACKWARD_STEP_FUNC(i) \ + typedef iter_fold_if_backward_step< \ + typename BOOST_PP_CAT(forward_step,BOOST_PP_DEC(i))::iterator \ + , typename BOOST_PP_CAT(backward_step,i)::state \ + , BackwardOp \ + , BackwardPredicate \ + > BOOST_PP_CAT(backward_step,BOOST_PP_DEC(i)); \ + /**/ + +# define AUX_ITER_FOLD_BACKWARD_STEP(unused, i, unused2) \ + AUX_ITER_FOLD_BACKWARD_STEP_FUNC( \ + BOOST_PP_SUB_D(1,BOOST_MPL_LIMIT_UNROLLING,i) \ + ) \ + /**/ + +# define AUX_LAST_FORWARD_STEP \ + BOOST_PP_CAT(forward_step, BOOST_MPL_LIMIT_UNROLLING) \ + /**/ + +# define AUX_LAST_BACKWARD_STEP \ + BOOST_PP_CAT(backward_step, BOOST_MPL_LIMIT_UNROLLING) \ + /**/ + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step forward_step0; + BOOST_PP_REPEAT( + BOOST_MPL_LIMIT_UNROLLING + , AUX_ITER_FOLD_FORWARD_STEP + , unused + ) + + typedef typename if_< + typename AUX_LAST_FORWARD_STEP::not_last + , iter_fold_if_impl< + typename AUX_LAST_FORWARD_STEP::iterator + , typename AUX_LAST_FORWARD_STEP::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename AUX_LAST_FORWARD_STEP::iterator + , typename AUX_LAST_FORWARD_STEP::state + > + >::type AUX_LAST_BACKWARD_STEP; + + BOOST_PP_REPEAT( + BOOST_MPL_LIMIT_UNROLLING + , AUX_ITER_FOLD_BACKWARD_STEP + , unused + ) + + public: + typedef typename backward_step0::state state; + typedef typename AUX_LAST_BACKWARD_STEP::iterator iterator; +}; + +# undef AUX_LAST_BACKWARD_STEP +# undef AUX_LAST_FORWARD_STEP +# undef AUX_ITER_FOLD_BACKWARD_STEP +# undef AUX_ITER_FOLD_BACKWARD_STEP_FUNC +# undef AUX_ITER_FOLD_FORWARD_STEP + +}}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_fold_impl.hpp new file mode 100644 index 0000000000..4d444db28b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_fold_impl.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/iter_fold_impl.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.5 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# include +# include +# endif +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER iter_fold_impl.hpp +# include + +#else + +# define AUX778076_FOLD_IMPL_OP(iter) iter +# define AUX778076_FOLD_IMPL_NAME_PREFIX iter_fold +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/iter_push_front.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_push_front.hpp new file mode 100644 index 0000000000..fad997eaf1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/iter_push_front.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED +#define BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/iter_push_front.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< + typename Sequence + , typename Iterator + > +struct iter_push_front +{ + typedef typename push_front< + Sequence + , typename deref::type + >::type type; +}; + +}}} + +#endif // BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/joint_iter.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/joint_iter.hpp new file mode 100644 index 0000000000..d510b147c6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/joint_iter.hpp @@ -0,0 +1,120 @@ + +#ifndef BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED +#define BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/joint_iter.hpp,v $ +// $Date: 2004/10/01 16:29:34 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# include +#endif + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename Iterator1 + , typename LastIterator1 + , typename Iterator2 + > +struct joint_iter +{ + typedef Iterator1 base; + typedef forward_iterator_tag category; +}; + +template< + typename LastIterator1 + , typename Iterator2 + > +struct joint_iter +{ + typedef Iterator2 base; + typedef forward_iterator_tag category; +}; + + +template< typename I1, typename L1, typename I2 > +struct deref< joint_iter > +{ + typedef typename joint_iter::base base_; + typedef typename deref::type type; +}; + +template< typename I1, typename L1, typename I2 > +struct next< joint_iter > +{ + typedef joint_iter< typename mpl::next::type,L1,I2 > type; +}; + +template< typename L1, typename I2 > +struct next< joint_iter > +{ + typedef joint_iter< L1,L1,typename mpl::next::type > type; +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template< + typename Iterator1 + , typename LastIterator1 + , typename Iterator2 + > +struct joint_iter; + +template< bool > struct joint_iter_impl +{ + template< typename I1, typename L1, typename I2 > struct result_ + { + typedef I1 base; + typedef forward_iterator_tag category; + typedef joint_iter< typename mpl::next::type,L1,I2 > next; + typedef typename deref::type type; + }; +}; + +template<> struct joint_iter_impl +{ + template< typename I1, typename L1, typename I2 > struct result_ + { + typedef I2 base; + typedef forward_iterator_tag category; + typedef joint_iter< L1,L1,typename mpl::next::type > next; + typedef typename deref::type type; + }; +}; + +template< + typename Iterator1 + , typename LastIterator1 + , typename Iterator2 + > +struct joint_iter + : joint_iter_impl< is_same::value > + ::template result_ +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, joint_iter) + +}} + +#endif // BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp index f4c3e503e2..c6bf160904 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/lambda_arity_param.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_no_ctps.hpp new file mode 100644 index 0000000000..721ede40bb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_no_ctps.hpp @@ -0,0 +1,193 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED +#define BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/lambda_no_ctps.hpp,v $ +// $Date: 2004/09/07 12:24:48 $ +// $Revision: 1.14 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER lambda_no_ctps.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +# define AUX778076_LAMBDA_PARAMS(i_, param) \ + BOOST_MPL_PP_PARAMS(i_, param) \ + /**/ + +namespace aux { + +#define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY +template< + BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false) + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) > + : false_ +{ +}; +#undef n_ + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +# undef AUX778076_LAMBDA_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED + +///// iteration, depth == 1 + +#else + +#define i_ BOOST_PP_FRAME_ITERATION(1) + +# define AUX778076_LAMBDA_TYPEDEF(unused, i_, F) \ + typedef lambda< \ + typename F::BOOST_PP_CAT(arg,BOOST_PP_INC(i_)) \ + , Tag \ + , false_ \ + > BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \ + /**/ + +# define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \ + typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \ + BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \ + /**/ + +# define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \ + BOOST_PP_COMMA_IF(i_) \ + BOOST_MPL_AUX_MSVC_VALUE_WKND(BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)))::value \ + /**/ + +# define AUX778076_LAMBDA_RESULT(unused, i_, unused2) \ + , typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::type \ + /**/ + +template<> struct lambda_impl< int_ > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, F) + BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused) + + typedef aux::lambda_or< + BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused) + > is_le; + + typedef BOOST_PP_CAT(bind,i_)< + typename F::rebind + BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_RESULT, unused) + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +# undef AUX778076_LAMBDA_RESULT +# undef AUX778076_IS_LAMBDA_EXPR +# undef AUX778076_IS_LE_TYPEDEF +# undef AUX778076_LAMBDA_TYPEDEF + +#undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_spec.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_spec.hpp new file mode 100644 index 0000000000..fe53da324d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_spec.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED +#define BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/lambda_spec.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) + +# define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i, name) \ +template< \ + BOOST_MPL_PP_PARAMS(i, typename T) \ + , typename Tag \ + > \ +struct lambda< \ + name< BOOST_MPL_PP_PARAMS(i, T) > \ + , Tag \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_) \ + > \ +{ \ + typedef false_ is_le; \ + typedef name< BOOST_MPL_PP_PARAMS(i, T) > type; \ +}; \ +/**/ + +#else + +# define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i, name) /**/ + +#endif + +#endif // BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp index 5d67d2a540..318d7bc6de 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/lambda_support.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/largest_int.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/largest_int.hpp new file mode 100644 index 0000000000..0c2a9c64d3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/largest_int.hpp @@ -0,0 +1,63 @@ + +#ifndef BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED +#define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/largest_int.hpp,v $ +// $Date: 2004/09/19 03:08:53 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename T > struct integral_rank; + +template<> struct integral_rank : int_<1> {}; +template<> struct integral_rank : int_<2> {}; +template<> struct integral_rank : int_<3> {}; +template<> struct integral_rank : int_<4> {}; +#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) +template<> struct integral_rank : int_<5> {}; +#endif +template<> struct integral_rank : int_<6> {}; +template<> struct integral_rank : int_<7> {}; +template<> struct integral_rank : int_<8> {}; +template<> struct integral_rank : int_<9> {}; +template<> struct integral_rank : int_<10> {}; +template<> struct integral_rank : int_<11> {}; + +#if defined(BOOST_HAS_LONG_LONG) +template<> struct integral_rank : int_<12> {}; +template<> struct integral_rank: int_<13> {}; +#endif + +template< typename T1, typename T2 > struct largest_int +#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) + : if_c< + ( integral_rank::value >= integral_rank::value ) + , T1 + , T2 + > +{ +#else +{ + enum { rank1 = integral_rank::value }; + enum { rank2 = integral_rank::value }; + typedef typename if_c< (rank1 >= rank2),T1,T2 >::type type; +#endif +}; + +}}} + +#endif // BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/logical_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/logical_op.hpp new file mode 100644 index 0000000000..1341301c85 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/logical_op.hpp @@ -0,0 +1,165 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/logical_op.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.3 $ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace boost { namespace mpl { + +# define AUX778076_PARAMS(param, sub) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, sub) \ + , param \ + ) \ + /**/ + +# define AUX778076_SHIFTED_PARAMS(param, sub) \ + BOOST_MPL_PP_EXT_PARAMS( \ + 2, BOOST_MPL_PP_SUB(BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY), sub) \ + , param \ + ) \ + /**/ + +# define AUX778076_SPEC_PARAMS(param) \ + BOOST_MPL_PP_ENUM( \ + BOOST_PP_DEC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) \ + , param \ + ) \ + /**/ + +namespace aux { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< bool C_, AUX778076_PARAMS(typename T, 1) > +struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) + : BOOST_PP_CAT(AUX778076_OP_VALUE1,_) +{ +}; + +template< AUX778076_PARAMS(typename T, 1) > +struct BOOST_PP_CAT(AUX778076_OP_NAME,impl)< AUX778076_OP_VALUE2,AUX778076_PARAMS(T, 1) > + : BOOST_PP_CAT(AUX778076_OP_NAME,impl)< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , AUX778076_SHIFTED_PARAMS(T, 1) + , BOOST_PP_CAT(AUX778076_OP_VALUE2,_) + > +{ +}; + +template<> +struct BOOST_PP_CAT(AUX778076_OP_NAME,impl)< + AUX778076_OP_VALUE2 + , AUX778076_SPEC_PARAMS(BOOST_PP_CAT(AUX778076_OP_VALUE2,_)) + > + : BOOST_PP_CAT(AUX778076_OP_VALUE2,_) +{ +}; + +#else + +template< bool C_ > struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) +{ + template< AUX778076_PARAMS(typename T, 1) > struct result_ + : BOOST_PP_CAT(AUX778076_OP_VALUE1,_) + { + }; +}; + +template<> struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) +{ + template< AUX778076_PARAMS(typename T, 1) > struct result_ + : BOOST_PP_CAT(AUX778076_OP_NAME,impl)< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< AUX778076_SHIFTED_PARAMS(T,1),BOOST_PP_CAT(AUX778076_OP_VALUE2,_) > + { + }; + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) + template<> struct result_ + : BOOST_PP_CAT(AUX778076_OP_VALUE2,_) + { + }; +}; +#else +}; + +template<> +struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) + ::result_< AUX778076_SPEC_PARAMS(BOOST_PP_CAT(AUX778076_OP_VALUE2,_)) > + : BOOST_PP_CAT(AUX778076_OP_VALUE2,_) +{ +}; +#endif // BOOST_MSVC == 1300 + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename T, BOOST_PP_CAT(AUX778076_OP_VALUE2,_)) + > +struct AUX778076_OP_NAME +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + : aux::BOOST_PP_CAT(AUX778076_OP_NAME,impl)< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , AUX778076_SHIFTED_PARAMS(T,0) + > +#else + : aux::BOOST_PP_CAT(AUX778076_OP_NAME,impl)< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< AUX778076_SHIFTED_PARAMS(T,0) > +#endif +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + BOOST_MPL_LIMIT_METAFUNCTION_ARITY + , AUX778076_OP_NAME + , (AUX778076_PARAMS(T, 0)) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , BOOST_MPL_LIMIT_METAFUNCTION_ARITY + , AUX778076_OP_NAME + ) + +}} + +#undef AUX778076_SPEC_PARAMS +#undef AUX778076_SHIFTED_PARAMS +#undef AUX778076_PARAMS +#undef AUX778076_OP_NAME +#undef AUX778076_OP_VALUE1 +#undef AUX778076_OP_VALUE2 diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_dtw.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_dtw.hpp new file mode 100644 index 0000000000..38c2c24e42 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_dtw.hpp @@ -0,0 +1,68 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/msvc_dtw.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.4 $ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +#include + +// local macros, #undef-ined at the end of the header +#define AUX778076_DTW_PARAMS(param) \ + BOOST_MPL_PP_PARAMS(AUX778076_MSVC_DTW_ARITY, param) \ +/**/ + +#define AUX778076_DTW_ORIGINAL_NAME \ + AUX778076_MSVC_DTW_ORIGINAL_NAME \ +/**/ + +// warning: not a well-formed C++ +// workaround for MSVC 6.5's "dependent template typedef bug" + +template< typename F> +struct AUX778076_MSVC_DTW_NAME +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { +#if AUX778076_MSVC_DTW_ARITY > 0 + template< AUX778076_DTW_PARAMS(typename P) > struct AUX778076_DTW_ORIGINAL_NAME + { + typedef int type; + }; + }; + + template< AUX778076_DTW_PARAMS(typename T) > struct result_ + : f_< aux::msvc_never_true::value > + ::template AUX778076_DTW_ORIGINAL_NAME< AUX778076_DTW_PARAMS(T) > + { + }; +#else + template< typename P = int > struct AUX778076_DTW_ORIGINAL_NAME + { + typedef int type; + }; + }; + + template< typename T = int > struct result_ + : f_< aux::msvc_never_true::value > + ::template AUX778076_DTW_ORIGINAL_NAME<> + { + }; +#endif +}; + +#undef AUX778076_DTW_ORIGINAL_NAME +#undef AUX778076_DTW_PARAMS + +#undef AUX778076_MSVC_DTW_NAME +#undef AUX778076_MSVC_DTW_ORIGINAL_NAME +#undef AUX778076_MSVC_DTW_ARITY diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_eti_base.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_eti_base.hpp new file mode 100644 index 0000000000..ad45c7e45d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_eti_base.hpp @@ -0,0 +1,77 @@ + +#ifndef BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED +#define BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/msvc_eti_base.hpp,v $ +// $Date: 2004/11/28 01:37:05 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { namespace aux { + +#if defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) + +template< bool > struct msvc_eti_base_impl +{ + template< typename T > struct result_ + : T + { + typedef T type; + }; +}; + +template<> struct msvc_eti_base_impl +{ + template< typename T > struct result_ + { + typedef result_ type; + typedef result_ first; + typedef result_ second; + typedef result_ tag; + enum { value = 0 }; + }; +}; + +template< typename T > struct msvc_eti_base + : msvc_eti_base_impl< is_msvc_eti_arg::value > + ::template result_ +{ +}; + +#else // !BOOST_MPL_CFG_MSVC_70_ETI_BUG + +template< typename T > struct msvc_eti_base + : T +{ +#if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) + msvc_eti_base(); +#endif + typedef T type; +}; + +#endif + +template<> struct msvc_eti_base +{ + typedef msvc_eti_base type; + typedef msvc_eti_base first; + typedef msvc_eti_base second; + typedef msvc_eti_base tag; + enum { value = 0 }; +}; + +}}} + +#endif // BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_is_class.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_is_class.hpp new file mode 100644 index 0000000000..d9a0f8fcf2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_is_class.hpp @@ -0,0 +1,58 @@ + +#ifndef BOOST_MPL_AUX_MSVC_IS_CLASS_HPP_INCLUDED +#define BOOST_MPL_AUX_MSVC_IS_CLASS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/msvc_is_class.hpp,v $ +// $Date: 2004/09/28 13:56:59 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename T > struct is_class_helper +{ + typedef int (T::* type)(); +}; + +// MSVC 6.x-specific lightweight 'is_class' implementation; +// Distinguishing feature: does not instantiate the type being tested. +template< typename T > +struct msvc_is_class_impl +{ + template< typename U> + static yes_tag test(type_wrapper*, /*typename*/ is_class_helper::type = 0); + static no_tag test(void const volatile*, ...); + + enum { value = sizeof(test((type_wrapper*)0)) == sizeof(yes_tag) }; + typedef bool_ type; +}; + +// agurt, 17/sep/04: have to check for 'is_reference' upfront to avoid ICEs in +// complex metaprograms +template< typename T > +struct msvc_is_class + : if_< + is_reference + , false_ + , msvc_is_class_impl + >::type +{ +}; + +}}} + +#endif // BOOST_MPL_AUX_MSVC_IS_CLASS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_never_true.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_never_true.hpp new file mode 100644 index 0000000000..2418cdd51c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_never_true.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED +#define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/msvc_never_true.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.5 $ + +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +namespace boost { namespace mpl { namespace aux { + +template< typename T > +struct msvc_never_true +{ + enum { value = false }; +}; + +}}} + +#endif // BOOST_MSVC + +#endif // BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_type.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_type.hpp new file mode 100644 index 0000000000..126fbddf42 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/msvc_type.hpp @@ -0,0 +1,62 @@ + +#ifndef BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED +#define BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/msvc_type.hpp,v $ +// $Date: 2004/09/02 15:40:43 $ +// $Revision: 1.1 $ + +#include +#include + +namespace boost { namespace mpl { namespace aux { + +#if defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) + +template< bool > struct msvc_type_impl +{ + template< typename T > struct result_ + { + typedef typename T::type type; + }; +}; + +template<> struct msvc_type_impl +{ + template< typename T > struct result_ + { + typedef result_ type; + }; +}; + +template< typename T > struct msvc_type + : msvc_type_impl< is_msvc_eti_arg::value > + ::template result_ +{ +}; + +#else // BOOST_MPL_CFG_MSVC_70_ETI_BUG + +template< typename T > struct msvc_type +{ + typedef typename T::type type; +}; + +template<> struct msvc_type +{ + typedef int type; +}; + +#endif + +}}} + +#endif // BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/na.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/na.hpp index 416fe5da93..3f68d4521b 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/na.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/na.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/na.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/na_assert.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/na_assert.hpp new file mode 100644 index 0000000000..6d8c70d7fd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/na_assert.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED +#define BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/na_assert.hpp,v $ +// $Date: 2005/07/13 13:13:38 $ +// $Revision: 1.6 $ + +#include +#include +#include + +#if !BOOST_WORKAROUND(_MSC_FULL_VER, <= 140050601) \ + && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) +# include +# define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ + BOOST_MPL_ASSERT_NOT((boost::mpl::is_na)) \ +/**/ +#else +# include +# define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ + BOOST_STATIC_ASSERT(!boost::mpl::is_na::value) \ +/**/ +#endif + +#endif // BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/na_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/na_fwd.hpp index 7c330f8054..4ba703c81f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/na_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/na_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/na_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/na_spec.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/na_spec.hpp index 4e36124a93..4a77a08b9e 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/na_spec.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/na_spec.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/na_spec.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/nested_type_wknd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/nested_type_wknd.hpp new file mode 100644 index 0000000000..0b8c02e458 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/nested_type_wknd.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED +#define BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/nested_type_wknd.hpp,v $ +// $Date: 2004/09/28 13:56:59 $ +// $Revision: 1.7 $ + +#include +#include + +#if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x530)) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + +namespace boost { namespace mpl { namespace aux { +template< typename T > struct nested_type_wknd + : T::type +{ +}; +}}} + +#if BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \ + aux::nested_type_wknd \ +/**/ +#else +# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \ + ::boost::mpl::aux::nested_type_wknd \ +/**/ +#endif + +#else // !BOOST_MPL_CFG_GCC et al. + +# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) T::type + +#endif + +#endif // BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/nttp_decl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/nttp_decl.hpp index 4f48f24b27..0caec1ba8e 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/nttp_decl.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/nttp_decl.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/nttp_decl.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp new file mode 100644 index 0000000000..4afb11b24f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp @@ -0,0 +1,77 @@ + +#ifndef BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED +#define BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/numeric_cast_utils.hpp,v $ +// $Date: 2004/11/28 01:39:23 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< + typename F + , typename Tag1 + , typename Tag2 + > +struct cast1st_impl +{ + template< typename N1, typename N2 > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : apply_wrap2< + F + , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N1 >::type + , N2 + > + { +#else + { + typedef typename apply_wrap2< + F + , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N1 >::type + , N2 + >::type type; +#endif + }; +}; + +template< + typename F + , typename Tag1 + , typename Tag2 + > +struct cast2nd_impl +{ + template< typename N1, typename N2 > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : apply_wrap2< + F + , N1 + , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N2 >::type + > + { +#else + { + typedef typename apply_wrap2< + F + , N1 + , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N2 >::type + >::type type; +#endif + }; +}; + +}}} + +#endif // BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/numeric_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/numeric_op.hpp new file mode 100644 index 0000000000..95ef6e41e3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/numeric_op.hpp @@ -0,0 +1,311 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/numeric_op.hpp,v $ +// $Date: 2004/12/20 19:17:06 $ +// $Revision: 1.9 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +#endif + +#include + +#if defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + || defined(BOOST_MPL_PREPROCESSING_MODE) + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + + +#if !defined(AUX778076_OP_ARITY) +# define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY +#endif + +#if !defined(AUX778076_OP_IMPL_NAME) +# define AUX778076_OP_IMPL_NAME BOOST_PP_CAT(AUX778076_OP_PREFIX,_impl) +#endif + +#if !defined(AUX778076_OP_TAG_NAME) +# define AUX778076_OP_TAG_NAME BOOST_PP_CAT(AUX778076_OP_PREFIX,_tag) +#endif + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct AUX778076_OP_IMPL_NAME + : if_c< + ( tag1_ > tag2_ ) +#else + > +struct AUX778076_OP_IMPL_NAME + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) +#endif + , aux::cast2nd_impl< AUX778076_OP_IMPL_NAME,Tag1,Tag2 > + , aux::cast1st_impl< AUX778076_OP_IMPL_NAME,Tag1,Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct AUX778076_OP_IMPL_NAME +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template< typename Tag > struct AUX778076_OP_IMPL_NAME +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct AUX778076_OP_IMPL_NAME +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; +#else +template<> struct AUX778076_OP_IMPL_NAME +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct AUX778076_OP_IMPL_NAME +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; +#endif + + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && BOOST_WORKAROUND(BOOST_MSVC, != 1200) +template< typename T > struct AUX778076_OP_TAG_NAME + : tag +{ +}; +#else +template< typename T > struct AUX778076_OP_TAG_NAME +{ + typedef typename T::tag type; +}; +#endif + + +#if AUX778076_OP_ARITY != 2 + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +# define AUX778076_OP_RIGHT_OPERAND(unused, i, N) , BOOST_PP_CAT(N, BOOST_MPL_PP_ADD(i, 2))> +# define AUX778076_OP_N_CALLS(i, N) \ + BOOST_MPL_PP_REPEAT( BOOST_PP_DEC(i), BOOST_MPL_PP_REPEAT_IDENTITY_FUNC, AUX778076_OP_NAME< ) \ + N1 BOOST_MPL_PP_REPEAT( BOOST_MPL_PP_SUB(i, 1), AUX778076_OP_RIGHT_OPERAND, N ) \ +/**/ + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename N, na) + > +struct AUX778076_OP_NAME + : AUX778076_OP_N_CALLS(AUX778076_OP_ARITY, N) +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + AUX778076_OP_ARITY + , AUX778076_OP_NAME + , ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) ) + ) +}; + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,( BOOST_PP_DEC(AUX778076_OP_ARITY), 2, )) +#include BOOST_PP_ITERATE() + +# undef AUX778076_OP_N_CALLS +# undef AUX778076_OP_RIGHT_OPERAND + +# else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +/// forward declaration +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct BOOST_PP_CAT(AUX778076_OP_NAME,2); + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename N, na) + > +struct AUX778076_OP_NAME +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) + : aux::msvc_eti_base< typename if_< +#else + : if_< +#endif + is_na + , BOOST_PP_CAT(AUX778076_OP_NAME,2) + , AUX778076_OP_NAME< + BOOST_PP_CAT(AUX778076_OP_NAME,2) + , BOOST_MPL_PP_EXT_PARAMS(3, BOOST_PP_INC(AUX778076_OP_ARITY), N) + > + >::type +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) + > +#endif +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + AUX778076_OP_ARITY + , AUX778076_OP_NAME + , ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct BOOST_PP_CAT(AUX778076_OP_NAME,2) + +#endif + +#else // AUX778076_OP_ARITY == 2 + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct AUX778076_OP_NAME + +#endif + +#if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) + : AUX778076_OP_IMPL_NAME< + typename AUX778076_OP_TAG_NAME::type + , typename AUX778076_OP_TAG_NAME::type + >::template apply::type +#else + : aux::msvc_eti_base< typename apply_wrap2< + AUX778076_OP_IMPL_NAME< + typename AUX778076_OP_TAG_NAME::type + , typename AUX778076_OP_TAG_NAME::type + > + , N1 + , N2 + >::type >::type +#endif +{ +#if AUX778076_OP_ARITY != 2 + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + AUX778076_OP_ARITY + , AUX778076_OP_NAME + , ( BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(2, N, na) ) + ) +# else + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, BOOST_PP_CAT(AUX778076_OP_NAME,2), (N1, N2)) +# endif + +#else + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, AUX778076_OP_NAME, (N1, N2)) +#endif +}; + +BOOST_MPL_AUX_NA_SPEC2(2, AUX778076_OP_ARITY, AUX778076_OP_NAME) + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + BOOST_MPL_PP_PARAMS(i_, typename N) + > +struct AUX778076_OP_NAME +#if i_ != 2 + : AUX778076_OP_N_CALLS(i_, N) +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + AUX778076_OP_ARITY + , AUX778076_OP_NAME + , ( BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(i_, N, na) ) + ) +}; +#endif + +# undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/order_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/order_impl.hpp new file mode 100644 index 0000000000..4a5bc9a7a4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/order_impl.hpp @@ -0,0 +1,76 @@ + +#ifndef BOOST_MPL_AUX_ORDER_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_ORDER_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/order_impl.hpp,v $ +// $Date: 2004/10/13 18:23:20 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; requires 'Seq' to provide corresponding overloads +// of BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY + +template< typename Seq, typename Key > struct x_order_impl +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) +{ + BOOST_STATIC_CONSTANT(long, value = + sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY( + Seq + , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) + ) ) + ); + + typedef long_ type; + +#else // ISO98 C++ + : long_< + sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY( + Seq + , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) + ) ) + > +{ +#endif +}; + +template< typename Tag > +struct order_impl +{ + template< typename Seq, typename Key > struct apply + : if_< + typename has_key_impl::template apply + , x_order_impl + , void_ + >::type + { + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,order_impl) + +}} + +#endif // BOOST_MPL_AUX_ORDER_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/overload_names.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/overload_names.hpp new file mode 100644 index 0000000000..09593f673c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/overload_names.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_AUX_OVERLOAD_NAMES_HPP_INCLUDED +#define BOOST_MPL_AUX_OVERLOAD_NAMES_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/overload_names.hpp,v $ +// $Date: 2004/10/13 18:23:20 $ +// $Revision: 1.2 $ + +#include +#include + +#if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) + +# include + +# define BOOST_MPL_AUX_OVERLOAD_VALUE_BY_KEY operator/ +# define BOOST_MPL_AUX_OVERLOAD_ITEM_BY_ORDER operator| +# define BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY operator|| +# define BOOST_MPL_AUX_OVERLOAD_IS_MASKED operator% + +# define BOOST_MPL_AUX_OVERLOAD_CALL_VALUE_BY_KEY(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) / x +# define BOOST_MPL_AUX_OVERLOAD_CALL_ITEM_BY_ORDER(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) | x +# define BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) || x +# define BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) % x + +#else + +# define BOOST_MPL_AUX_OVERLOAD_VALUE_BY_KEY value_by_key_ +# define BOOST_MPL_AUX_OVERLOAD_ITEM_BY_ORDER item_by_order_ +# define BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY order_by_key_ +# define BOOST_MPL_AUX_OVERLOAD_IS_MASKED is_masked_ + +# define BOOST_MPL_AUX_OVERLOAD_CALL_VALUE_BY_KEY(T, x) T::BOOST_MPL_AUX_OVERLOAD_VALUE_BY_KEY( BOOST_MPL_AUX_PTR_TO_REF(T), x ) +# define BOOST_MPL_AUX_OVERLOAD_CALL_ITEM_BY_ORDER(T, x) T::BOOST_MPL_AUX_OVERLOAD_ITEM_BY_ORDER( BOOST_MPL_AUX_PTR_TO_REF(T), x ) +# define BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY(T, x) T::BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY( BOOST_MPL_AUX_PTR_TO_REF(T), x ) +# define BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED(T, x) T::BOOST_MPL_AUX_OVERLOAD_IS_MASKED( BOOST_MPL_AUX_PTR_TO_REF(T), x ) + +#endif + +#endif // BOOST_MPL_AUX_OVERLOAD_NAMES_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/partition_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/partition_op.hpp new file mode 100644 index 0000000000..63233aea50 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/partition_op.hpp @@ -0,0 +1,58 @@ + +#ifndef BOOST_MPL_AUX_PARTITION_OP_HPP_INCLUDED +#define BOOST_MPL_AUX_PARTITION_OP_HPP_INCLUDED + +// Copyright Eric Friedman 2003 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/partition_op.hpp,v $ +// $Date: 2004/11/28 01:46:37 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< typename Pred, typename In1Op, typename In2Op > +struct partition_op +{ + template< typename State, typename T > + struct apply + { + typedef typename State::first first_; + typedef typename State::second second_; + typedef typename apply1< Pred,T >::type pred_; + + typedef typename eval_if< + pred_ + , apply2 + , apply2 + >::type result_; + + typedef typename if_< + pred_ + , pair< result_,second_ > + , pair< first_,result_ > + >::type type; + }; +}; + +} // namespace aux + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::partition_op) + +}} + +#endif // BOOST_MPL_AUX_PARTITION_OP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/pop_back_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/pop_back_impl.hpp new file mode 100644 index 0000000000..dfe0c916dc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/pop_back_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_POP_BACK_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_POP_BACK_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/pop_back_impl.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +// no default implementation; the definition is needed to make MSVC happy + +template< typename Tag > +struct pop_back_impl +{ + template< typename Sequence > struct apply; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, pop_back_impl) + +}} + +#endif // BOOST_MPL_AUX_POP_BACK_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/pop_front_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/pop_front_impl.hpp new file mode 100644 index 0000000000..d80e2d1507 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/pop_front_impl.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/pop_front_impl.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// no default implementation; the definition is needed to make MSVC happy + +template< typename Tag > +struct pop_front_impl +{ + template< typename Sequence > struct apply + // conservatively placed, but maybe should go outside surrounding + // braces. +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + { + typedef int type; + } +#endif + ; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, pop_front_impl) + +}} + +#endif // BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/and.hpp new file mode 100644 index 0000000000..010ad1fc84 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/and.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply.hpp new file mode 100644 index 0000000000..e08eaccf03 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp new file mode 100644 index 0000000000..2ffe7091bc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp @@ -0,0 +1,456 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + int N, typename F + > +struct apply_wrap_impl0; + +template< + typename F + > +struct apply_wrap_impl0< + 0 + , F + + > +{ + typedef typename F::template apply< + +/// since the defaults are "lost", we have to pass *something* even for nullary +/// metafunction classes + na + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 1 + , F + + > +{ + typedef typename F::template apply< + + na + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 2 + , F + + > +{ + typedef typename F::template apply< + + na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 3 + , F + + > +{ + typedef typename F::template apply< + + na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 4 + , F + + > +{ + typedef typename F::template apply< + + na, na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 5 + , F + + > +{ + typedef typename F::template apply< + + na, na, na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap0 + : apply_wrap_impl0< + ::boost::mpl::aux::arity< F,0 >::value + , F + + >::type +{ +}; + +template< + int N, typename F, typename T1 + > +struct apply_wrap_impl1; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 1 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 2 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 3 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 4 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 5 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na, na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap1 + : apply_wrap_impl1< + ::boost::mpl::aux::arity< F,1 >::value + , F + , T1 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2 + > +struct apply_wrap_impl2; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 2 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 3 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 4 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na, na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 5 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na, na, na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap2 + : apply_wrap_impl2< + ::boost::mpl::aux::arity< F,2 >::value + , F + , T1, T2 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 3 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 4 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 5 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + , na, na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap3 + : apply_wrap_impl3< + ::boost::mpl::aux::arity< F,3 >::value + , F + , T1, T2, T3 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4< + 4 + , F + , T1, T2, T3, T4 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4< + 5 + , F + , T1, T2, T3, T4 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap4 + : apply_wrap_impl4< + ::boost::mpl::aux::arity< F,4 >::value + , F + , T1, T2, T3, T4 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap_impl5; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap_impl5< + 5 + , F + , T1, T2, T3, T4, T5 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4, T5 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap5 + : apply_wrap_impl5< + ::boost::mpl::aux::arity< F,5 >::value + , F + , T1, T2, T3, T4, T5 + >::type +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/arg.hpp new file mode 100644 index 0000000000..9a766e79ce --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/arg.hpp @@ -0,0 +1,117 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp new file mode 100644 index 0000000000..d24e2245a9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp @@ -0,0 +1,300 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bind.hpp new file mode 100644 index 0000000000..edafd0cf5d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bind.hpp @@ -0,0 +1,397 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1, typename U2, typename U3, typename U4, typename U5 + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp new file mode 100644 index 0000000000..022cba3461 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitand.hpp new file mode 100644 index 0000000000..0bbf54ea26 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitand.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitor.hpp new file mode 100644 index 0000000000..55b31cb8a9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp new file mode 100644 index 0000000000..ec1939151d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/divides.hpp new file mode 100644 index 0000000000..86f16826f7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/divides.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp new file mode 100644 index 0000000000..62c994589f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp new file mode 100644 index 0000000000..e3eef71b1e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp @@ -0,0 +1,558 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Arity + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg,Tag, int_< -1 > > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + , int_<1> + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + , int_<1> + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + , int_<2> + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + , int_<2> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + , int_<3> + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + , int_<3> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + , int_<4> + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + , int_<4> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + , int_<5> + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + , int_<5> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + , int_<6> + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect,Tag, int_<1> > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + , int_<6> + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +template< + typename F + , typename Tag1 + , typename Tag2 + , typename Arity + > +struct lambda< + lambda< F,Tag1,Arity > + , Tag2 + , int_<3> + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef bind1< quote1, typename l1::result_ > arity_; + typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3; + typedef aux::le_result3 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/greater.hpp new file mode 100644 index 0000000000..14d8e08bff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/greater.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp new file mode 100644 index 0000000000..2603f9184a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/inherit.hpp new file mode 100644 index 0000000000..31ab0dc490 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/inherit.hpp @@ -0,0 +1,139 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1, typename T2, typename T3, typename T4, typename T5 + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/less.hpp new file mode 100644 index 0000000000..4fe3cd17c4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/less.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp new file mode 100644 index 0000000000..ca2894f6f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/minus.hpp new file mode 100644 index 0000000000..71d4913766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/minus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/modulus.hpp new file mode 100644 index 0000000000..224b34930c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/modulus.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp new file mode 100644 index 0000000000..98b21b1e22 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/or.hpp new file mode 100644 index 0000000000..31e1aaa4e6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/or.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/plus.hpp new file mode 100644 index 0000000000..a9f6ee79a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/plus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/quote.hpp new file mode 100644 index 0000000000..e7a7f00196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/quote.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp new file mode 100644 index 0000000000..7a07414adf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< long N > +struct reverse_fold_chunk; + +template<> struct reverse_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step; + +template< + typename Last + , typename State + > +struct reverse_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_fold_null_step< Last,State > + , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step +{ + typedef reverse_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl + : reverse_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..39a4057b77 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< long N > +struct reverse_iter_fold_chunk; + +template<> struct reverse_iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step; + +template< + typename Last + , typename State + > +struct reverse_iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_iter_fold_null_step< Last,State > + , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step +{ + typedef reverse_iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl + : reverse_iter_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp new file mode 100644 index 0000000000..b5b181ce19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp new file mode 100644 index 0000000000..f7a342e989 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp new file mode 100644 index 0000000000..1164f0f8c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp @@ -0,0 +1,40 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_< -1 > + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/times.hpp new file mode 100644 index 0000000000..cb97cc4e13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/times.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp new file mode 100644 index 0000000000..ef7c2b016e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + { + typedef typename aux::unpack_args_impl< + size::value + , F + , Args + >::type type; + + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/and.hpp new file mode 100644 index 0000000000..010ad1fc84 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/and.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply.hpp new file mode 100644 index 0000000000..e08eaccf03 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp new file mode 100644 index 0000000000..2ffe7091bc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp @@ -0,0 +1,456 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + int N, typename F + > +struct apply_wrap_impl0; + +template< + typename F + > +struct apply_wrap_impl0< + 0 + , F + + > +{ + typedef typename F::template apply< + +/// since the defaults are "lost", we have to pass *something* even for nullary +/// metafunction classes + na + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 1 + , F + + > +{ + typedef typename F::template apply< + + na + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 2 + , F + + > +{ + typedef typename F::template apply< + + na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 3 + , F + + > +{ + typedef typename F::template apply< + + na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 4 + , F + + > +{ + typedef typename F::template apply< + + na, na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 5 + , F + + > +{ + typedef typename F::template apply< + + na, na, na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap0 + : apply_wrap_impl0< + ::boost::mpl::aux::arity< F,0 >::value + , F + + >::type +{ +}; + +template< + int N, typename F, typename T1 + > +struct apply_wrap_impl1; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 1 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 2 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 3 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 4 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 5 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na, na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap1 + : apply_wrap_impl1< + ::boost::mpl::aux::arity< F,1 >::value + , F + , T1 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2 + > +struct apply_wrap_impl2; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 2 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 3 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 4 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na, na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 5 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na, na, na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap2 + : apply_wrap_impl2< + ::boost::mpl::aux::arity< F,2 >::value + , F + , T1, T2 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 3 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 4 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 5 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + , na, na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap3 + : apply_wrap_impl3< + ::boost::mpl::aux::arity< F,3 >::value + , F + , T1, T2, T3 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4< + 4 + , F + , T1, T2, T3, T4 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4< + 5 + , F + , T1, T2, T3, T4 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap4 + : apply_wrap_impl4< + ::boost::mpl::aux::arity< F,4 >::value + , F + , T1, T2, T3, T4 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap_impl5; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap_impl5< + 5 + , F + , T1, T2, T3, T4, T5 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4, T5 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap5 + : apply_wrap_impl5< + ::boost::mpl::aux::arity< F,5 >::value + , F + , T1, T2, T3, T4, T5 + >::type +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp new file mode 100644 index 0000000000..a29daa0bca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp @@ -0,0 +1,306 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bind.hpp new file mode 100644 index 0000000000..34b1b5c8b3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bind.hpp @@ -0,0 +1,403 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp new file mode 100644 index 0000000000..022cba3461 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp new file mode 100644 index 0000000000..0bbf54ea26 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp new file mode 100644 index 0000000000..55b31cb8a9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp new file mode 100644 index 0000000000..ec1939151d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/divides.hpp new file mode 100644 index 0000000000..86f16826f7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/divides.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp new file mode 100644 index 0000000000..62c994589f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp new file mode 100644 index 0000000000..e3eef71b1e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp @@ -0,0 +1,558 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Arity + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg,Tag, int_< -1 > > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + , int_<1> + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + , int_<1> + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + , int_<2> + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + , int_<2> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + , int_<3> + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + , int_<3> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + , int_<4> + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + , int_<4> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + , int_<5> + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + , int_<5> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + , int_<6> + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect,Tag, int_<1> > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + , int_<6> + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +template< + typename F + , typename Tag1 + , typename Tag2 + , typename Arity + > +struct lambda< + lambda< F,Tag1,Arity > + , Tag2 + , int_<3> + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef bind1< quote1, typename l1::result_ > arity_; + typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3; + typedef aux::le_result3 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/greater.hpp new file mode 100644 index 0000000000..14d8e08bff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/greater.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp new file mode 100644 index 0000000000..2603f9184a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp new file mode 100644 index 0000000000..00f31c4226 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/less.hpp new file mode 100644 index 0000000000..4fe3cd17c4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/less.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp new file mode 100644 index 0000000000..ca2894f6f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/minus.hpp new file mode 100644 index 0000000000..71d4913766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/minus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp new file mode 100644 index 0000000000..224b34930c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp new file mode 100644 index 0000000000..98b21b1e22 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/or.hpp new file mode 100644 index 0000000000..31e1aaa4e6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/or.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/plus.hpp new file mode 100644 index 0000000000..a9f6ee79a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/plus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/quote.hpp new file mode 100644 index 0000000000..e7a7f00196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/quote.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp new file mode 100644 index 0000000000..7a07414adf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< long N > +struct reverse_fold_chunk; + +template<> struct reverse_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step; + +template< + typename Last + , typename State + > +struct reverse_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_fold_null_step< Last,State > + , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step +{ + typedef reverse_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl + : reverse_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..39a4057b77 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< long N > +struct reverse_iter_fold_chunk; + +template<> struct reverse_iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step; + +template< + typename Last + , typename State + > +struct reverse_iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_iter_fold_null_step< Last,State > + , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step +{ + typedef reverse_iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl + : reverse_iter_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp new file mode 100644 index 0000000000..b5b181ce19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp new file mode 100644 index 0000000000..f7a342e989 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp new file mode 100644 index 0000000000..1164f0f8c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp @@ -0,0 +1,40 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_< -1 > + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/times.hpp new file mode 100644 index 0000000000..cb97cc4e13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/times.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp new file mode 100644 index 0000000000..ef7c2b016e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + { + typedef typename aux::unpack_args_impl< + size::value + , F + , Args + >::type type; + + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/and.hpp new file mode 100644 index 0000000000..010ad1fc84 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/and.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply.hpp new file mode 100644 index 0000000000..e08eaccf03 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp new file mode 100644 index 0000000000..34d51a1a58 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp @@ -0,0 +1,84 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + + : F::template apply< > +{ +}; + +template< typename F > +struct apply_wrap0< F,true_ > + : F::apply +{ +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + + : F::template apply +{ +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + + : F::template apply< T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + + : F::template apply< T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + + : F::template apply< T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + + : F::template apply< T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp new file mode 100644 index 0000000000..1e73429418 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp @@ -0,0 +1,406 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F, int dummy_ + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, int dummy_ + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1, int dummy_ + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, int dummy_ + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2, int dummy_ + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, int dummy_ + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, int dummy_ + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, int dummy_ + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , int dummy_ + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , int dummy_ + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, int dummy_ + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, int dummy_ + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bind.hpp new file mode 100644 index 0000000000..94bfe1fef7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bind.hpp @@ -0,0 +1,515 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F, int dummy_ + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, int dummy_ + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1, int dummy_ + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, int dummy_ + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2, int dummy_ + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, int dummy_ + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, int dummy_ + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, int dummy_ + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , int dummy_ + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , int dummy_ + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, int dummy_ + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, int dummy_ + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp new file mode 100644 index 0000000000..181bc77faa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp @@ -0,0 +1,53 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, int dummy_ = 0 + > +struct bind; + +template< + typename F, int dummy_ = 0 + > +struct bind0; + +template< + typename F, typename T1, int dummy_ = 0 + > +struct bind1; + +template< + typename F, typename T1, typename T2, int dummy_ = 0 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3, int dummy_ = 0 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , int dummy_ = 0 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, int dummy_ = 0 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitand.hpp new file mode 100644 index 0000000000..0bbf54ea26 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitand.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitor.hpp new file mode 100644 index 0000000000..55b31cb8a9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp new file mode 100644 index 0000000000..ec1939151d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/divides.hpp new file mode 100644 index 0000000000..86f16826f7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/divides.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp new file mode 100644 index 0000000000..62c994589f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp new file mode 100644 index 0000000000..026418ccc9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp @@ -0,0 +1,536 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/greater.hpp new file mode 100644 index 0000000000..14d8e08bff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/greater.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp new file mode 100644 index 0000000000..2603f9184a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/inherit.hpp new file mode 100644 index 0000000000..00f31c4226 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/inherit.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/less.hpp new file mode 100644 index 0000000000..4fe3cd17c4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/less.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp new file mode 100644 index 0000000000..ca2894f6f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/minus.hpp new file mode 100644 index 0000000000..71d4913766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/minus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/modulus.hpp new file mode 100644 index 0000000000..224b34930c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/modulus.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp new file mode 100644 index 0000000000..98b21b1e22 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/or.hpp new file mode 100644 index 0000000000..31e1aaa4e6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/or.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/plus.hpp new file mode 100644 index 0000000000..a9f6ee79a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/plus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/quote.hpp new file mode 100644 index 0000000000..d7d0420e4d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/quote.hpp @@ -0,0 +1,123 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename T, bool has_type_ > +struct quote_impl + : T +{ +}; + +template< typename T > +struct quote_impl< T,false > +{ + typedef T type; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< + F + , aux::has_type< F >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< + F< U1,U2 > + , aux::has_type< F< U1,U2 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< + F< U1,U2,U3 > + , aux::has_type< F< U1,U2,U3 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4 > + , aux::has_type< F< U1,U2,U3,U4 > >::value + > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4,U5 > + , aux::has_type< F< U1,U2,U3,U4,U5 > >::value + > + + { + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp new file mode 100644 index 0000000000..c468684c91 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..658f92a7c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp new file mode 100644 index 0000000000..b5b181ce19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp new file mode 100644 index 0000000000..f7a342e989 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp new file mode 100644 index 0000000000..a23fc23846 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/times.hpp new file mode 100644 index 0000000000..cb97cc4e13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/times.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp new file mode 100644 index 0000000000..2194ce9d11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value,F, Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/and.hpp new file mode 100644 index 0000000000..010ad1fc84 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/and.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp new file mode 100644 index 0000000000..e08eaccf03 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp new file mode 100644 index 0000000000..34d51a1a58 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp @@ -0,0 +1,84 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + + : F::template apply< > +{ +}; + +template< typename F > +struct apply_wrap0< F,true_ > + : F::apply +{ +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + + : F::template apply +{ +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + + : F::template apply< T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + + : F::template apply< T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + + : F::template apply< T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + + : F::template apply< T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp new file mode 100644 index 0000000000..b0702324aa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp @@ -0,0 +1,440 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +template< + template< typename T1, typename T2, typename T3 > class F, typename Tag + > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct eval_if; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< eval_if,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename eval_if< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp new file mode 100644 index 0000000000..0e9513a649 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp @@ -0,0 +1,561 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +template< + template< typename T1, typename T2, typename T3 > class F, typename Tag + > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct eval_if; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< eval_if,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename eval_if< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp new file mode 100644 index 0000000000..c4a5060ff8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct bind; + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitand.hpp new file mode 100644 index 0000000000..0bbf54ea26 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitand.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitor.hpp new file mode 100644 index 0000000000..55b31cb8a9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp new file mode 100644 index 0000000000..ec1939151d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/divides.hpp new file mode 100644 index 0000000000..86f16826f7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/divides.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp new file mode 100644 index 0000000000..62c994589f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp new file mode 100644 index 0000000000..e3eef71b1e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp @@ -0,0 +1,558 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Arity + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg,Tag, int_< -1 > > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + , int_<1> + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + , int_<1> + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + , int_<2> + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + , int_<2> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + , int_<3> + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + , int_<3> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + , int_<4> + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + , int_<4> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + , int_<5> + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + , int_<5> + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + , int_<6> + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect,Tag, int_<1> > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + , int_<6> + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +template< + typename F + , typename Tag1 + , typename Tag2 + , typename Arity + > +struct lambda< + lambda< F,Tag1,Arity > + , Tag2 + , int_<3> + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef bind1< quote1, typename l1::result_ > arity_; + typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3; + typedef aux::le_result3 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp new file mode 100644 index 0000000000..14d8e08bff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp new file mode 100644 index 0000000000..2603f9184a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/inherit.hpp new file mode 100644 index 0000000000..00f31c4226 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/inherit.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/less.hpp new file mode 100644 index 0000000000..4fe3cd17c4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/less.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp new file mode 100644 index 0000000000..ca2894f6f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp new file mode 100644 index 0000000000..71d4913766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/modulus.hpp new file mode 100644 index 0000000000..224b34930c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/modulus.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp new file mode 100644 index 0000000000..98b21b1e22 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/or.hpp new file mode 100644 index 0000000000..31e1aaa4e6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/or.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp new file mode 100644 index 0000000000..a9f6ee79a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp new file mode 100644 index 0000000000..d7d0420e4d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp @@ -0,0 +1,123 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename T, bool has_type_ > +struct quote_impl + : T +{ +}; + +template< typename T > +struct quote_impl< T,false > +{ + typedef T type; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< + F + , aux::has_type< F >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< + F< U1,U2 > + , aux::has_type< F< U1,U2 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< + F< U1,U2,U3 > + , aux::has_type< F< U1,U2,U3 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4 > + , aux::has_type< F< U1,U2,U3,U4 > >::value + > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4,U5 > + , aux::has_type< F< U1,U2,U3,U4,U5 > >::value + > + + { + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp new file mode 100644 index 0000000000..c468684c91 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..658f92a7c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp new file mode 100644 index 0000000000..b5b181ce19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp new file mode 100644 index 0000000000..f7a342e989 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp new file mode 100644 index 0000000000..3e7bfba1ea --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< int N > struct arity_tag +{ + typedef char (&type)[N + 1]; +}; + +template< + int C1, int C2, int C3, int C4, int C5, int C6 + > +struct max_arity +{ + BOOST_STATIC_CONSTANT(int, value = + ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) ) + + ); +}; + +arity_tag<0>::type arity_helper(...); + +template< + template< typename P1 > class F + , typename T1 + > +typename arity_tag<1>::type +arity_helper(type_wrapper< F >, arity_tag<1>); + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + > +typename arity_tag<2>::type +arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>); + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + > +typename arity_tag<3>::type +arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>); + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + > +typename arity_tag<4>::type +arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>); + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + > +typename arity_tag<5>::type +arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>); + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6 + > +typename arity_tag<6>::type +arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>); +template< typename F, int N > +struct template_arity_impl +{ + BOOST_STATIC_CONSTANT(int, value = + sizeof(arity_helper(type_wrapper(), arity_tag())) - 1 + ); +}; + +template< typename F > +struct template_arity +{ + BOOST_STATIC_CONSTANT(int, value = ( + max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value + + )); + + typedef mpl::int_ type; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/times.hpp new file mode 100644 index 0000000000..cb97cc4e13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/times.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp new file mode 100644 index 0000000000..2194ce9d11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value,F, Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp new file mode 100644 index 0000000000..36337c8a34 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp @@ -0,0 +1,132 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp new file mode 100644 index 0000000000..4ffbe78da7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp @@ -0,0 +1,132 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; + + /// ETI workaround + template<> struct apply + { + typedef int type; + }; + +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/and.hpp new file mode 100644 index 0000000000..555c800167 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/and.hpp @@ -0,0 +1,73 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool C_ > struct and_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : false_ + { + }; +}; + +template<> struct and_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,true_ > + { + }; +}; + +template<> +struct and_impl + ::result_< true_,true_,true_,true_ > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,T5 > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply.hpp new file mode 100644 index 0000000000..a3e2929ff8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply.hpp @@ -0,0 +1,166 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + +{ + typedef typename apply_wrap0< + typename lambda::type + + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +/// workaround for ETI bug +template<> +struct apply0 +{ + typedef int type; +}; + +template< + typename F, typename T1 + > +struct apply1 + +{ + typedef typename apply_wrap1< + typename lambda::type + , T1 + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +/// workaround for ETI bug +template<> +struct apply1< int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + +{ + typedef typename apply_wrap2< + typename lambda::type + , T1, T2 + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +/// workaround for ETI bug +template<> +struct apply2< int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + +{ + typedef typename apply_wrap3< + typename lambda::type + , T1, T2, T3 + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +/// workaround for ETI bug +template<> +struct apply3< int,int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + +{ + typedef typename apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +/// workaround for ETI bug +template<> +struct apply4< int,int,int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + +{ + typedef typename apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// workaround for ETI bug +template<> +struct apply5< int,int,int,int,int,int > +{ + typedef int type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp new file mode 100644 index 0000000000..f0f86c1766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp new file mode 100644 index 0000000000..4e89507d90 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp @@ -0,0 +1,247 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename F> +struct msvc_apply0 +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { + template< typename P = int > struct apply + { + typedef int type; + }; + }; + + template< typename T = int > struct result_ + : f_< aux::msvc_never_true::value > + ::template apply<> + { + }; + +}; + +template< + typename F + > +struct apply_wrap0 +{ + typedef typename msvc_apply0::template result_< + + >::type type; +}; + +/// workaround for ETI bug +template<> +struct apply_wrap0 +{ + typedef int type; +}; + +template< typename F> +struct msvc_apply1 +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { + template< typename P1 > struct apply + { + typedef int type; + }; + }; + + template< typename T1 > struct result_ + : f_< aux::msvc_never_true::value > + ::template apply + { + }; +}; + +template< + typename F, typename T1 + > +struct apply_wrap1 +{ + typedef typename msvc_apply1::template result_< + T1 + >::type type; +}; + +/// workaround for ETI bug +template<> +struct apply_wrap1< int,int > +{ + typedef int type; +}; + +template< typename F> +struct msvc_apply2 +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { + template< typename P1, typename P2 > struct apply + { + typedef int type; + }; + }; + + template< typename T1, typename T2 > struct result_ + : f_< aux::msvc_never_true::value > + ::template apply< T1,T2 > + { + }; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap2 +{ + typedef typename msvc_apply2::template result_< + T1, T2 + >::type type; +}; + +/// workaround for ETI bug +template<> +struct apply_wrap2< int,int,int > +{ + typedef int type; +}; + +template< typename F> +struct msvc_apply3 +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { + template< typename P1, typename P2, typename P3 > struct apply + { + typedef int type; + }; + }; + + template< typename T1, typename T2, typename T3 > struct result_ + : f_< aux::msvc_never_true::value > + ::template apply< T1,T2,T3 > + { + }; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap3 +{ + typedef typename msvc_apply3::template result_< + T1, T2, T3 + >::type type; +}; + +/// workaround for ETI bug +template<> +struct apply_wrap3< int,int,int,int > +{ + typedef int type; +}; + +template< typename F> +struct msvc_apply4 +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { + template< + typename P1, typename P2, typename P3, typename P4 + > + struct apply + { + typedef int type; + }; + }; + + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : f_< aux::msvc_never_true::value > + ::template apply< T1,T2,T3,T4 > + { + }; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap4 +{ + typedef typename msvc_apply4::template result_< + T1, T2, T3, T4 + >::type type; +}; + +/// workaround for ETI bug +template<> +struct apply_wrap4< int,int,int,int,int > +{ + typedef int type; +}; + +template< typename F> +struct msvc_apply5 +{ + template< bool > struct f_ : F {}; + template<> struct f_ + { + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + struct apply + { + typedef int type; + }; + }; + + template< + typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + : f_< aux::msvc_never_true::value > + ::template apply< T1,T2,T3,T4,T5 > + { + }; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap5 +{ + typedef typename msvc_apply5::template result_< + T1, T2, T3, T4, T5 + >::type type; +}; + +/// workaround for ETI bug +template<> +struct apply_wrap5< int,int,int,int,int,int > +{ + typedef int type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp new file mode 100644 index 0000000000..4f12a40f04 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp @@ -0,0 +1,328 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool > +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef typename apply_wrap5< + T + , U1, U2, U3, U4, U5 + >::type type; + }; +}; + +template< typename T > struct is_bind_template; + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,U1,U2,U3,U4,U5 > +{ +}; + +template< int arity_ > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +template< int N > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F + > +aux::yes_tag +is_bind_helper(bind0*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1 + > +aux::yes_tag +is_bind_helper(bind1< F,T1 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2 + > +aux::yes_tag +is_bind_helper(bind2< F,T1,T2 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3 + > +aux::yes_tag +is_bind_helper(bind3< F,T1,T2,T3 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +aux::yes_tag +is_bind_helper(bind4< F,T1,T2,T3,T4 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag +is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bind.hpp new file mode 100644 index 0000000000..53c76e8f2a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bind.hpp @@ -0,0 +1,432 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool > +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef typename apply_wrap5< + T + , U1, U2, U3, U4, U5 + >::type type; + }; +}; + +template< typename T > struct is_bind_template; + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,U1,U2,U3,U4,U5 > +{ +}; + +template< typename T > +struct replace_unnamed_arg_impl +{ + template< typename Arg > struct result_ + { + typedef Arg next; + typedef T type; + }; +}; + +template<> +struct replace_unnamed_arg_impl< arg< -1 > > +{ + template< typename Arg > struct result_ + { + typedef typename next::type next; + typedef Arg type; + }; +}; + +template< typename T, typename Arg > +struct replace_unnamed_arg + : replace_unnamed_arg_impl::template result_ +{ +}; + +template< int arity_ > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +template< int N > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F + > +aux::yes_tag +is_bind_helper(bind0*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1 + > +aux::yes_tag +is_bind_helper(bind1< F,T1 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2 + > +aux::yes_tag +is_bind_helper(bind2< F,T1,T2 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3 + > +aux::yes_tag +is_bind_helper(bind3< F,T1,T2,T3 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +aux::yes_tag +is_bind_helper(bind4< F,T1,T2,T3,T4 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag +is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp new file mode 100644 index 0000000000..022cba3461 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp new file mode 100644 index 0000000000..e96cf1a726 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp @@ -0,0 +1,149 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct bitand_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitand_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitand_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitand_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + + : if_< + + is_na + , bitand_2< N1,N2 > + , bitand_< + bitand_2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitand_2 + : aux::msvc_eti_base< typename apply_wrap2< + bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitand_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitand_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 & n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitand_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp new file mode 100644 index 0000000000..bbc96ab7ae --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp @@ -0,0 +1,149 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct bitor_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitor_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitor_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitor_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + + : if_< + + is_na + , bitor_2< N1,N2 > + , bitor_< + bitor_2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitor_2 + : aux::msvc_eti_base< typename apply_wrap2< + bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitor_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitor_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 | n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitor_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp new file mode 100644 index 0000000000..4c1429712c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp @@ -0,0 +1,149 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct bitxor_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitxor_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitxor_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitxor_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + + : if_< + + is_na + , bitxor_2< N1,N2 > + , bitxor_< + bitxor_2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitxor_2 + : aux::msvc_eti_base< typename apply_wrap2< + bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitxor_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitxor_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 ^ n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitxor_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/deque.hpp new file mode 100644 index 0000000000..a0445d9dfd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/deque.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct deque_chooser; + +} + +namespace aux { + +template<> +struct deque_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef vector0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_deque_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_deque_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct deque_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque_impl +{ + typedef aux::deque_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::deque_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque + : aux::deque_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::deque_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/divides.hpp new file mode 100644 index 0000000000..7681491922 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/divides.hpp @@ -0,0 +1,148 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct divides_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct divides_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct divides_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct divides2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + + : if_< + + is_na + , divides2< N1,N2 > + , divides< + divides2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct divides2 + : aux::msvc_eti_base< typename apply_wrap2< + divides_impl< + typename divides_tag::type + , typename divides_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, divides2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct divides_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 / n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::divides_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp new file mode 100644 index 0000000000..64e9065027 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct equal_to_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct equal_to_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct equal_to_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + : aux::msvc_eti_base< typename apply_wrap2< + equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp new file mode 100644 index 0000000000..4b3c69076a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp @@ -0,0 +1,293 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< int N > +struct fold_chunk; + +template<> struct fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< int N > +struct fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_step; + +template< + typename Last + , typename State + > +struct fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , fold_null_step< Last,State > + , fold_step< First,Last,State,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_step +{ + typedef fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl + : fold_chunk + ::template result_< First,Last,State,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp new file mode 100644 index 0000000000..bf818731eb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/greater.hpp new file mode 100644 index 0000000000..5f5662dedd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/greater.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct greater_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + : aux::msvc_eti_base< typename apply_wrap2< + greater_impl< + typename greater_tag::type + , typename greater_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp new file mode 100644 index 0000000000..ae776fcc5b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct greater_equal_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_equal_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_equal_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + : aux::msvc_eti_base< typename apply_wrap2< + greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp new file mode 100644 index 0000000000..233a1ec30c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp @@ -0,0 +1,166 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C1, bool C2 > +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1, T2 + { + typedef Derived type_; + }; +}; + +template<> +struct inherit2_impl< false,true > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1 + { + typedef T1 type_; + }; +}; + +template<> +struct inherit2_impl< true,false > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T2 + { + typedef T2 type_; + }; +}; + +template<> +struct inherit2_impl< true,true > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + { + typedef T1 type_; + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : aux::inherit2_impl< + is_empty_base::value + , is_empty_base::value + >::template result_< inherit2< T1,T2 >,T1, T2 > +{ + typedef typename inherit2::type_ type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp new file mode 100644 index 0000000000..69aadc46b6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp @@ -0,0 +1,293 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< int N > +struct iter_fold_chunk; + +template<> struct iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< int N > +struct iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_step; + +template< + typename Last + , typename State + > +struct iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , iter_fold_null_step< Last,State > + , iter_fold_step< First,Last,State,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_step +{ + typedef iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl + : iter_fold_chunk + ::template result_< First,Last,State,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/less.hpp new file mode 100644 index 0000000000..951f060827 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/less.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct less_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + : aux::msvc_eti_base< typename apply_wrap2< + less_impl< + typename less_tag::type + , typename less_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > + BOOST_MPL_AUX_VALUE_WKND(N1)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp new file mode 100644 index 0000000000..a56e692e3e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct less_equal_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_equal_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_equal_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + : aux::msvc_eti_base< typename apply_wrap2< + less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/list.hpp new file mode 100644 index 0000000000..e5ea456c9e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/list.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct list_chooser; + +} + +namespace aux { + +template<> +struct list_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef list0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_list_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_list_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct list_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list_impl +{ + typedef aux::list_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::list_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list + : aux::list_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::list_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp new file mode 100644 index 0000000000..ab25482f55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct list_c_chooser; + +} + +namespace aux { + +template<> +struct list_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_list_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_list_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct list_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c_impl +{ + typedef aux::list_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::list_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c + : aux::list_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::list_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/map.hpp new file mode 100644 index 0000000000..970e0b7602 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/map.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct map_chooser; + +} + +namespace aux { + +template<> +struct map_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef map0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_map_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_map_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct map_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map_impl +{ + typedef aux::map_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::map_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map + : aux::map_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::map_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/minus.hpp new file mode 100644 index 0000000000..b47f328574 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/minus.hpp @@ -0,0 +1,148 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct minus_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct minus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct minus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct minus2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + + : if_< + + is_na + , minus2< N1,N2 > + , minus< + minus2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct minus2 + : aux::msvc_eti_base< typename apply_wrap2< + minus_impl< + typename minus_tag::type + , typename minus_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct minus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 - n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::minus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp new file mode 100644 index 0000000000..c12b3f9ff6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp @@ -0,0 +1,115 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct modulus_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct modulus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct modulus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + : aux::msvc_eti_base< typename apply_wrap2< + modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct modulus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 % n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::modulus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp new file mode 100644 index 0000000000..6e56b1e89f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct not_equal_to_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct not_equal_to_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct not_equal_to_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + : aux::msvc_eti_base< typename apply_wrap2< + not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/or.hpp new file mode 100644 index 0000000000..3f7394e7cc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/or.hpp @@ -0,0 +1,73 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool C_ > struct or_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : true_ + { + }; +}; + +template<> struct or_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,false_ > + { + }; +}; + +template<> +struct or_impl + ::result_< false_,false_,false_,false_ > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,T5 > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/plus.hpp new file mode 100644 index 0000000000..105233537b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/plus.hpp @@ -0,0 +1,148 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct plus_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct plus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct plus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct plus2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + + : if_< + + is_na + , plus2< N1,N2 > + , plus< + plus2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct plus2 + : aux::msvc_eti_base< typename apply_wrap2< + plus_impl< + typename plus_tag::type + , typename plus_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, plus2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct plus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 + n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::plus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/quote.hpp new file mode 100644 index 0000000000..e7a7f00196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/quote.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp new file mode 100644 index 0000000000..adf15b633d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp @@ -0,0 +1,343 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< long N > +struct reverse_fold_chunk; + +template<> struct reverse_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< long N > +struct reverse_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step; + +template< + typename Last + , typename State + > +struct reverse_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_fold_null_step< Last,State > + , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step +{ + typedef reverse_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl + : reverse_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..208ad97069 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp @@ -0,0 +1,343 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< long N > +struct reverse_iter_fold_chunk; + +template<> struct reverse_iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template<> struct reverse_iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< long N > +struct reverse_iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step; + +template< + typename Last + , typename State + > +struct reverse_iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_iter_fold_null_step< Last,State > + , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; + + /// ETI workaround + template<> struct result_< int,int,int,int,int > + { + typedef int state; + typedef int iterator; + }; + +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step +{ + typedef reverse_iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl + : reverse_iter_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/set.hpp new file mode 100644 index 0000000000..95aaa5cbdf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/set.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct set_chooser; + +} + +namespace aux { + +template<> +struct set_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef set0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_set_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_set_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct set_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set_impl +{ + typedef aux::set_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::set_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set + : aux::set_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::set_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp new file mode 100644 index 0000000000..1ff34f9032 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct set_c_chooser; + +} + +namespace aux { + +template<> +struct set_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_set_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_set_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct set_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c_impl +{ + typedef aux::set_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::set_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c + : aux::set_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::set_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp new file mode 100644 index 0000000000..3861ca1db1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp @@ -0,0 +1,114 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct shift_left_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_left_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_left_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + : aux::msvc_eti_base< typename apply_wrap2< + shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct shift_left_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n << s)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + : aux::shift_left_wknd< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp new file mode 100644 index 0000000000..24ea0948e7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp @@ -0,0 +1,114 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct shift_right_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_right_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_right_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + : aux::msvc_eti_base< typename apply_wrap2< + shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct shift_right_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n >> s)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + : aux::shift_right_wknd< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp new file mode 100644 index 0000000000..1668771349 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_< -1 > + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +template<> +struct template_arity + : mpl::int_< -1 > +{ +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/times.hpp new file mode 100644 index 0000000000..dee7fd4427 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/times.hpp @@ -0,0 +1,148 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct times_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct times_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct times_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct times2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + + : if_< + + is_na + , times2< N1,N2 > + , times< + times2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct times2 + : aux::msvc_eti_base< typename apply_wrap2< + times_impl< + typename times_tag::type + , typename times_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, times2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct times_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 * n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::times_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp new file mode 100644 index 0000000000..26533dd423 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp @@ -0,0 +1,109 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl +{ + template< typename F, typename Args > struct apply; +}; + +template<> struct unpack_args_impl<0> +{ + template< typename F, typename Args > struct apply + : apply0< + F + > + { + }; +}; + +template<> struct unpack_args_impl<1> +{ + template< typename F, typename Args > struct apply + : apply1< + F + , typename at_c< Args,0 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<2> +{ + template< typename F, typename Args > struct apply + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<3> +{ + template< typename F, typename Args > struct apply + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<4> +{ + template< typename F, typename Args > struct apply + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<5> +{ + template< typename F, typename Args > struct apply + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > + { + }; +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value > + ::template apply< F,Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/vector.hpp new file mode 100644 index 0000000000..a6c7b6219a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/vector.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct vector_chooser; + +} + +namespace aux { + +template<> +struct vector_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef vector0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_vector_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_vector_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct vector_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector_impl +{ + typedef aux::vector_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::vector_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector + : aux::vector_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::vector_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp new file mode 100644 index 0000000000..6cf7b449b7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct vector_c_chooser; + +} + +namespace aux { + +template<> +struct vector_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_vector_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_vector_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct vector_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c_impl +{ + typedef aux::vector_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::vector_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c + : aux::vector_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::vector_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/and.hpp new file mode 100644 index 0000000000..e58640a41c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/and.hpp @@ -0,0 +1,71 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool C_ > struct and_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : false_ + { + }; +}; + +template<> struct and_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,true_ > + { + }; + + template<> struct result_< true_,true_,true_,true_ > + : true_ + { + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,T5 > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply.hpp new file mode 100644 index 0000000000..d46d030968 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply.hpp @@ -0,0 +1,160 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +/// workaround for ETI bug +template<> +struct apply0 +{ + typedef int type; +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +/// workaround for ETI bug +template<> +struct apply1< int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +/// workaround for ETI bug +template<> +struct apply2< int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +/// workaround for ETI bug +template<> +struct apply3< int,int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +/// workaround for ETI bug +template<> +struct apply4< int,int,int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// workaround for ETI bug +template<> +struct apply5< int,int,int,int,int,int > +{ + typedef int type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp new file mode 100644 index 0000000000..f0f86c1766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp new file mode 100644 index 0000000000..d30751793c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp @@ -0,0 +1,138 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + +{ + typedef typename F::template apply< + + >::type type; + +}; + +/// workaround for ETI bug +template<> +struct apply_wrap0 +{ + typedef int type; +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + +{ + typedef typename F::template apply< + T1 + >::type type; + +}; + +/// workaround for ETI bug +template<> +struct apply_wrap1< int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + +{ + typedef typename F::template apply< + T1, T2 + >::type type; + +}; + +/// workaround for ETI bug +template<> +struct apply_wrap2< int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + +{ + typedef typename F::template apply< + T1, T2, T3 + >::type type; + +}; + +/// workaround for ETI bug +template<> +struct apply_wrap3< int,int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + +{ + typedef typename F::template apply< + T1, T2, T3, T4 + >::type type; + +}; + +/// workaround for ETI bug +template<> +struct apply_wrap4< int,int,int,int,int > +{ + typedef int type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + +{ + typedef typename F::template apply< + T1, T2, T3, T4, T5 + >::type type; + +}; + +/// workaround for ETI bug +template<> +struct apply_wrap5< int,int,int,int,int,int > +{ + typedef int type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp new file mode 100644 index 0000000000..4f12a40f04 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp @@ -0,0 +1,328 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool > +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef typename apply_wrap5< + T + , U1, U2, U3, U4, U5 + >::type type; + }; +}; + +template< typename T > struct is_bind_template; + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,U1,U2,U3,U4,U5 > +{ +}; + +template< int arity_ > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +template< int N > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F + > +aux::yes_tag +is_bind_helper(bind0*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1 + > +aux::yes_tag +is_bind_helper(bind1< F,T1 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2 + > +aux::yes_tag +is_bind_helper(bind2< F,T1,T2 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3 + > +aux::yes_tag +is_bind_helper(bind3< F,T1,T2,T3 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +aux::yes_tag +is_bind_helper(bind4< F,T1,T2,T3,T4 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag +is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bind.hpp new file mode 100644 index 0000000000..53c76e8f2a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bind.hpp @@ -0,0 +1,432 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool > +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef typename apply_wrap5< + T + , U1, U2, U3, U4, U5 + >::type type; + }; +}; + +template< typename T > struct is_bind_template; + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,U1,U2,U3,U4,U5 > +{ +}; + +template< typename T > +struct replace_unnamed_arg_impl +{ + template< typename Arg > struct result_ + { + typedef Arg next; + typedef T type; + }; +}; + +template<> +struct replace_unnamed_arg_impl< arg< -1 > > +{ + template< typename Arg > struct result_ + { + typedef typename next::type next; + typedef Arg type; + }; +}; + +template< typename T, typename Arg > +struct replace_unnamed_arg + : replace_unnamed_arg_impl::template result_ +{ +}; + +template< int arity_ > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +template< int N > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F + > +aux::yes_tag +is_bind_helper(bind0*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1 + > +aux::yes_tag +is_bind_helper(bind1< F,T1 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2 + > +aux::yes_tag +is_bind_helper(bind2< F,T1,T2 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3 + > +aux::yes_tag +is_bind_helper(bind3< F,T1,T2,T3 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +aux::yes_tag +is_bind_helper(bind4< F,T1,T2,T3,T4 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag +is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp new file mode 100644 index 0000000000..022cba3461 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp new file mode 100644 index 0000000000..e54b4ce1d4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp @@ -0,0 +1,151 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct bitand_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitand_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitand_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitand_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + + : aux::msvc_eti_base< typename if_< + + is_na + , bitand_2< N1,N2 > + , bitand_< + bitand_2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitand_2 + : aux::msvc_eti_base< typename apply_wrap2< + bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitand_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitand_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 & n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitand_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp new file mode 100644 index 0000000000..3b465b332a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp @@ -0,0 +1,151 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct bitor_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitor_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitor_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitor_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + + : aux::msvc_eti_base< typename if_< + + is_na + , bitor_2< N1,N2 > + , bitor_< + bitor_2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitor_2 + : aux::msvc_eti_base< typename apply_wrap2< + bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitor_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitor_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 | n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitor_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp new file mode 100644 index 0000000000..f7c5d439c8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp @@ -0,0 +1,151 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct bitxor_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitxor_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitxor_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitxor_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + + : aux::msvc_eti_base< typename if_< + + is_na + , bitxor_2< N1,N2 > + , bitxor_< + bitxor_2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitxor_2 + : aux::msvc_eti_base< typename apply_wrap2< + bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitxor_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitxor_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 ^ n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitxor_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/deque.hpp new file mode 100644 index 0000000000..a0445d9dfd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/deque.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct deque_chooser; + +} + +namespace aux { + +template<> +struct deque_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef vector0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_deque_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_deque_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct deque_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque_impl +{ + typedef aux::deque_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::deque_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque + : aux::deque_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::deque_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/divides.hpp new file mode 100644 index 0000000000..0c60c4317a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/divides.hpp @@ -0,0 +1,150 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct divides_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct divides_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct divides_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct divides2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + + : aux::msvc_eti_base< typename if_< + + is_na + , divides2< N1,N2 > + , divides< + divides2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct divides2 + : aux::msvc_eti_base< typename apply_wrap2< + divides_impl< + typename divides_tag::type + , typename divides_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, divides2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct divides_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 / n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::divides_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp new file mode 100644 index 0000000000..107912b17f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct equal_to_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct equal_to_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct equal_to_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + : aux::msvc_eti_base< typename apply_wrap2< + equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp new file mode 100644 index 0000000000..58066d81f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp @@ -0,0 +1,245 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< int N > +struct fold_chunk; + +template<> struct fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; + }; +}; + +template<> struct fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; + }; +}; + +template<> struct fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; + }; +}; + +template<> struct fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; + }; +}; + +template< int N > +struct fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_step; + +template< + typename Last + , typename State + > +struct fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , fold_null_step< Last,State > + , fold_step< First,Last,State,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_step +{ + typedef fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl + : fold_chunk + ::template result_< First,Last,State,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp new file mode 100644 index 0000000000..bf818731eb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/greater.hpp new file mode 100644 index 0000000000..f60a86064a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/greater.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct greater_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + : aux::msvc_eti_base< typename apply_wrap2< + greater_impl< + typename greater_tag::type + , typename greater_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp new file mode 100644 index 0000000000..2ab09fd562 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct greater_equal_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_equal_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_equal_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + : aux::msvc_eti_base< typename apply_wrap2< + greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp new file mode 100644 index 0000000000..233a1ec30c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp @@ -0,0 +1,166 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C1, bool C2 > +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1, T2 + { + typedef Derived type_; + }; +}; + +template<> +struct inherit2_impl< false,true > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1 + { + typedef T1 type_; + }; +}; + +template<> +struct inherit2_impl< true,false > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T2 + { + typedef T2 type_; + }; +}; + +template<> +struct inherit2_impl< true,true > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + { + typedef T1 type_; + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : aux::inherit2_impl< + is_empty_base::value + , is_empty_base::value + >::template result_< inherit2< T1,T2 >,T1, T2 > +{ + typedef typename inherit2::type_ type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp new file mode 100644 index 0000000000..50ea754f2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp @@ -0,0 +1,245 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< int N > +struct iter_fold_chunk; + +template<> struct iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; + }; +}; + +template<> struct iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; + }; +}; + +template<> struct iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; + }; +}; + +template<> struct iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; + }; +}; + +template< int N > +struct iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_step; + +template< + typename Last + , typename State + > +struct iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , iter_fold_null_step< Last,State > + , iter_fold_step< First,Last,State,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_step +{ + typedef iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl + : iter_fold_chunk + ::template result_< First,Last,State,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/less.hpp new file mode 100644 index 0000000000..72338def7e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/less.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct less_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + : aux::msvc_eti_base< typename apply_wrap2< + less_impl< + typename less_tag::type + , typename less_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > + BOOST_MPL_AUX_VALUE_WKND(N1)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp new file mode 100644 index 0000000000..b588697559 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct less_equal_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_equal_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_equal_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + : aux::msvc_eti_base< typename apply_wrap2< + less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/list.hpp new file mode 100644 index 0000000000..e5ea456c9e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/list.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct list_chooser; + +} + +namespace aux { + +template<> +struct list_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef list0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_list_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_list_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct list_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list_impl +{ + typedef aux::list_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::list_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list + : aux::list_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::list_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp new file mode 100644 index 0000000000..ab25482f55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct list_c_chooser; + +} + +namespace aux { + +template<> +struct list_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_list_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_list_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct list_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c_impl +{ + typedef aux::list_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::list_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c + : aux::list_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::list_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/map.hpp new file mode 100644 index 0000000000..970e0b7602 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/map.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct map_chooser; + +} + +namespace aux { + +template<> +struct map_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef map0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_map_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_map_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct map_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map_impl +{ + typedef aux::map_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::map_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map + : aux::map_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::map_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/minus.hpp new file mode 100644 index 0000000000..3237fa6847 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/minus.hpp @@ -0,0 +1,150 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct minus_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct minus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct minus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct minus2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + + : aux::msvc_eti_base< typename if_< + + is_na + , minus2< N1,N2 > + , minus< + minus2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct minus2 + : aux::msvc_eti_base< typename apply_wrap2< + minus_impl< + typename minus_tag::type + , typename minus_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct minus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 - n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::minus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp new file mode 100644 index 0000000000..9c672c0f19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp @@ -0,0 +1,115 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct modulus_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct modulus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct modulus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + : aux::msvc_eti_base< typename apply_wrap2< + modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct modulus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 % n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::modulus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp new file mode 100644 index 0000000000..1e48e7f7af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp @@ -0,0 +1,102 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct not_equal_to_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct not_equal_to_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct not_equal_to_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + : aux::msvc_eti_base< typename apply_wrap2< + not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/or.hpp new file mode 100644 index 0000000000..8d0ba0a47a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/or.hpp @@ -0,0 +1,71 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool C_ > struct or_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : true_ + { + }; +}; + +template<> struct or_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,false_ > + { + }; + + template<> struct result_< false_,false_,false_,false_ > + : false_ + { + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,T5 > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/plus.hpp new file mode 100644 index 0000000000..c8f3355e75 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/plus.hpp @@ -0,0 +1,150 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct plus_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct plus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct plus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct plus2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + + : aux::msvc_eti_base< typename if_< + + is_na + , plus2< N1,N2 > + , plus< + plus2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct plus2 + : aux::msvc_eti_base< typename apply_wrap2< + plus_impl< + typename plus_tag::type + , typename plus_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, plus2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct plus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 + n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::plus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/quote.hpp new file mode 100644 index 0000000000..b85880ffdd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/quote.hpp @@ -0,0 +1,116 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { +template< bool > struct quote_impl +{ + template< typename T > struct result_ + : T + { + }; +}; + +template<> struct quote_impl +{ + template< typename T > struct result_ + { + typedef T type; + }; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< aux::has_type< F >::value > + ::template result_< F > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< aux::has_type< F< U1,U2 > >::value > + ::template result_< F< U1,U2 > > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< aux::has_type< F< U1,U2,U3 > >::value > + ::template result_< F< U1,U2,U3 > > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< aux::has_type< F< U1,U2,U3,U4 > >::value > + ::template result_< F< U1,U2,U3,U4 > > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< aux::has_type< F< U1,U2,U3,U4,U5 > >::value > + ::template result_< F< U1,U2,U3,U4,U5 > > + + { + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp new file mode 100644 index 0000000000..7a07414adf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< long N > +struct reverse_fold_chunk; + +template<> struct reverse_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step; + +template< + typename Last + , typename State + > +struct reverse_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_fold_null_step< Last,State > + , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step +{ + typedef reverse_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl + : reverse_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..39a4057b77 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< long N > +struct reverse_iter_fold_chunk; + +template<> struct reverse_iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step; + +template< + typename Last + , typename State + > +struct reverse_iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_iter_fold_null_step< Last,State > + , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step +{ + typedef reverse_iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl + : reverse_iter_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/set.hpp new file mode 100644 index 0000000000..95aaa5cbdf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/set.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct set_chooser; + +} + +namespace aux { + +template<> +struct set_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef set0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_set_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_set_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct set_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set_impl +{ + typedef aux::set_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::set_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set + : aux::set_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::set_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp new file mode 100644 index 0000000000..1ff34f9032 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct set_c_chooser; + +} + +namespace aux { + +template<> +struct set_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_set_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_set_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct set_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c_impl +{ + typedef aux::set_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::set_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c + : aux::set_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::set_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp new file mode 100644 index 0000000000..176fc00007 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp @@ -0,0 +1,114 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct shift_left_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_left_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_left_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + : aux::msvc_eti_base< typename apply_wrap2< + shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct shift_left_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n << s)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + : aux::shift_left_wknd< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp new file mode 100644 index 0000000000..6b6e01ff36 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp @@ -0,0 +1,114 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct shift_right_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_right_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_right_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag + : tag< T,na > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + : aux::msvc_eti_base< typename apply_wrap2< + shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct shift_right_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n >> s)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + : aux::shift_right_wknd< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp new file mode 100644 index 0000000000..1668771349 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp @@ -0,0 +1,46 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_< -1 > + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +template<> +struct template_arity + : mpl::int_< -1 > +{ +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/times.hpp new file mode 100644 index 0000000000..a6ae333cca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/times.hpp @@ -0,0 +1,150 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + + , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value + , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value + > +struct times_impl + : if_c< + ( tag1_ > tag2_ ) + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct times_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct times_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag + : tag< T,na > +{ +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct times2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + + : aux::msvc_eti_base< typename if_< + + is_na + , times2< N1,N2 > + , times< + times2< N1,N2 > + , N3, N4, N5 + > + >::type + + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct times2 + : aux::msvc_eti_base< typename apply_wrap2< + times_impl< + typename times_tag::type + , typename times_tag::type + > + , N1 + , N2 + >::type >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, times2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct times_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 * n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::times_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp new file mode 100644 index 0000000000..26533dd423 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp @@ -0,0 +1,109 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl +{ + template< typename F, typename Args > struct apply; +}; + +template<> struct unpack_args_impl<0> +{ + template< typename F, typename Args > struct apply + : apply0< + F + > + { + }; +}; + +template<> struct unpack_args_impl<1> +{ + template< typename F, typename Args > struct apply + : apply1< + F + , typename at_c< Args,0 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<2> +{ + template< typename F, typename Args > struct apply + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<3> +{ + template< typename F, typename Args > struct apply + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<4> +{ + template< typename F, typename Args > struct apply + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<5> +{ + template< typename F, typename Args > struct apply + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > + { + }; +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value > + ::template apply< F,Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/vector.hpp new file mode 100644 index 0000000000..a6c7b6219a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/vector.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct vector_chooser; + +} + +namespace aux { + +template<> +struct vector_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef vector0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_vector_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_vector_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct vector_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector_impl +{ + typedef aux::vector_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::vector_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector + : aux::vector_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::vector_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp new file mode 100644 index 0000000000..6cf7b449b7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct vector_c_chooser; + +} + +namespace aux { + +template<> +struct vector_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_vector_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_vector_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct vector_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c_impl +{ + typedef aux::vector_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::vector_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c + : aux::vector_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::vector_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/and.hpp new file mode 100644 index 0000000000..010ad1fc84 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/and.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply.hpp new file mode 100644 index 0000000000..e08eaccf03 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp new file mode 100644 index 0000000000..2ffe7091bc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp @@ -0,0 +1,456 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + int N, typename F + > +struct apply_wrap_impl0; + +template< + typename F + > +struct apply_wrap_impl0< + 0 + , F + + > +{ + typedef typename F::template apply< + +/// since the defaults are "lost", we have to pass *something* even for nullary +/// metafunction classes + na + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 1 + , F + + > +{ + typedef typename F::template apply< + + na + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 2 + , F + + > +{ + typedef typename F::template apply< + + na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 3 + , F + + > +{ + typedef typename F::template apply< + + na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 4 + , F + + > +{ + typedef typename F::template apply< + + na, na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap_impl0< + 5 + , F + + > +{ + typedef typename F::template apply< + + na, na, na, na, na + + > type; +}; + +template< + typename F + > +struct apply_wrap0 + : apply_wrap_impl0< + ::boost::mpl::aux::arity< F,0 >::value + , F + + >::type +{ +}; + +template< + int N, typename F, typename T1 + > +struct apply_wrap_impl1; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 1 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 2 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 3 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 4 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap_impl1< + 5 + , F + , T1 + > +{ + typedef typename F::template apply< + T1 + , na, na, na, na + + > type; +}; + +template< + typename F, typename T1 + > +struct apply_wrap1 + : apply_wrap_impl1< + ::boost::mpl::aux::arity< F,1 >::value + , F + , T1 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2 + > +struct apply_wrap_impl2; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 2 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 3 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 4 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na, na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap_impl2< + 5 + , F + , T1, T2 + > +{ + typedef typename F::template apply< + T1, T2 + + , na, na, na + + > type; +}; + +template< + typename F, typename T1, typename T2 + > +struct apply_wrap2 + : apply_wrap_impl2< + ::boost::mpl::aux::arity< F,2 >::value + , F + , T1, T2 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 3 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 4 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap_impl3< + 5 + , F + , T1, T2, T3 + > +{ + typedef typename F::template apply< + T1, T2, T3 + + , na, na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply_wrap3 + : apply_wrap_impl3< + ::boost::mpl::aux::arity< F,3 >::value + , F + , T1, T2, T3 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4< + 4 + , F + , T1, T2, T3, T4 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap_impl4< + 5 + , F + , T1, T2, T3, T4 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4 + + , na + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply_wrap4 + : apply_wrap_impl4< + ::boost::mpl::aux::arity< F,4 >::value + , F + , T1, T2, T3, T4 + >::type +{ +}; + +template< + int N, typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap_impl5; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap_impl5< + 5 + , F + , T1, T2, T3, T4, T5 + > +{ + typedef typename F::template apply< + T1, T2, T3, T4, T5 + + > type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply_wrap5 + : apply_wrap_impl5< + ::boost::mpl::aux::arity< F,5 >::value + , F + , T1, T2, T3, T4, T5 + >::type +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp new file mode 100644 index 0000000000..b0702324aa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp @@ -0,0 +1,440 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +template< + template< typename T1, typename T2, typename T3 > class F, typename Tag + > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct eval_if; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< eval_if,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename eval_if< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bind.hpp new file mode 100644 index 0000000000..0e9513a649 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bind.hpp @@ -0,0 +1,561 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +template< + template< typename T1, typename T2, typename T3 > class F, typename Tag + > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct eval_if; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< eval_if,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename eval_if< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp new file mode 100644 index 0000000000..c4a5060ff8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct bind; + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp new file mode 100644 index 0000000000..0bbf54ea26 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp new file mode 100644 index 0000000000..55b31cb8a9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp new file mode 100644 index 0000000000..ec1939151d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp @@ -0,0 +1,147 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/divides.hpp new file mode 100644 index 0000000000..86f16826f7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/divides.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp new file mode 100644 index 0000000000..62c994589f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp new file mode 100644 index 0000000000..bf818731eb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/greater.hpp new file mode 100644 index 0000000000..14d8e08bff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/greater.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp new file mode 100644 index 0000000000..2603f9184a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp new file mode 100644 index 0000000000..00f31c4226 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/less.hpp new file mode 100644 index 0000000000..4fe3cd17c4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/less.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp new file mode 100644 index 0000000000..ca2894f6f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/minus.hpp new file mode 100644 index 0000000000..71d4913766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/minus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp new file mode 100644 index 0000000000..224b34930c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp new file mode 100644 index 0000000000..98b21b1e22 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/or.hpp new file mode 100644 index 0000000000..31e1aaa4e6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/or.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/plus.hpp new file mode 100644 index 0000000000..a9f6ee79a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/plus.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/quote.hpp new file mode 100644 index 0000000000..d7d0420e4d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/quote.hpp @@ -0,0 +1,123 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename T, bool has_type_ > +struct quote_impl + : T +{ +}; + +template< typename T > +struct quote_impl< T,false > +{ + typedef T type; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< + F + , aux::has_type< F >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< + F< U1,U2 > + , aux::has_type< F< U1,U2 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< + F< U1,U2,U3 > + , aux::has_type< F< U1,U2,U3 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4 > + , aux::has_type< F< U1,U2,U3,U4 > >::value + > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4,U5 > + , aux::has_type< F< U1,U2,U3,U4,U5 > >::value + > + + { + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp new file mode 100644 index 0000000000..c468684c91 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..658f92a7c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp new file mode 100644 index 0000000000..b5b181ce19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp new file mode 100644 index 0000000000..f7a342e989 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp new file mode 100644 index 0000000000..a23fc23846 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/times.hpp new file mode 100644 index 0000000000..cb97cc4e13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/times.hpp @@ -0,0 +1,146 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp new file mode 100644 index 0000000000..2194ce9d11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value,F, Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/and.hpp new file mode 100644 index 0000000000..555c800167 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/and.hpp @@ -0,0 +1,73 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool C_ > struct and_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : false_ + { + }; +}; + +template<> struct and_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,true_ > + { + }; +}; + +template<> +struct and_impl + ::result_< true_,true_,true_,true_ > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,T5 > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp new file mode 100644 index 0000000000..9838e799b5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp @@ -0,0 +1,268 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +namespace aux { + +template<> +struct apply_chooser<0> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef apply0< + F + > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +namespace aux { + +template<> +struct apply_chooser<1> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef apply1< + F, T1 + > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +namespace aux { + +template<> +struct apply_chooser<2> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef apply2< + F, T1, T2 + > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +namespace aux { + +template<> +struct apply_chooser<3> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef apply3< + F, T1, T2, T3 + > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +namespace aux { + +template<> +struct apply_chooser<4> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef apply4< + F, T1, T2, T3, T4 + > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +namespace aux { + +template<> +struct apply_chooser<5> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef apply5< + F, T1, T2, T3, T4, T5 + > type; + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_apply_arg +{ + static bool const value = true; +}; + +template<> +struct is_apply_arg +{ + static bool const value = false; +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + > +struct apply_count_args +{ + static int const value = is_apply_arg::value + is_apply_arg::value + is_apply_arg::value + is_apply_arg::value + is_apply_arg::value; + +}; + +} + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply + : aux::apply_chooser< + aux::apply_count_args< T1,T2,T3,T4,T5 >::value + >::template result_< F,T1,T2,T3,T4,T5 >::type +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp new file mode 100644 index 0000000000..7de6dad088 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp @@ -0,0 +1,50 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser; +} + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp new file mode 100644 index 0000000000..efa213dfed --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp @@ -0,0 +1,78 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + + : F::template apply< > +{ +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + + : F::template apply +{ +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + + : F::template apply< T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + + : F::template apply< T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + + : F::template apply< T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + + : F::template apply< T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp new file mode 100644 index 0000000000..254e5b8886 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp @@ -0,0 +1,486 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool > +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef typename apply_wrap5< + T + , U1, U2, U3, U4, U5 + >::type type; + }; +}; + +template< typename T > struct is_bind_template; + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,U1,U2,U3,U4,U5 > +{ +}; + +template< int arity_ > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag is_bind_helper(bind< F,T1,T2,T3,T4,T5 >*); + +template< int N > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F + > +aux::yes_tag +is_bind_helper(bind0*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +namespace aux { + +template<> +struct bind_chooser<0> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind0 type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1 + > +aux::yes_tag +is_bind_helper(bind1< F,T1 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +namespace aux { + +template<> +struct bind_chooser<1> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind1< F,T1 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2 + > +aux::yes_tag +is_bind_helper(bind2< F,T1,T2 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +namespace aux { + +template<> +struct bind_chooser<2> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind2< F,T1,T2 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3 + > +aux::yes_tag +is_bind_helper(bind3< F,T1,T2,T3 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +namespace aux { + +template<> +struct bind_chooser<3> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind3< F,T1,T2,T3 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +aux::yes_tag +is_bind_helper(bind4< F,T1,T2,T3,T4 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +namespace aux { + +template<> +struct bind_chooser<4> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind4< F,T1,T2,T3,T4 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag +is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +namespace aux { + +template<> +struct bind_chooser<5> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind5< F,T1,T2,T3,T4,T5 > type; + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_bind_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_bind_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + > +struct bind_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_bind_arg::value + is_bind_arg::value + + is_bind_arg::value + is_bind_arg::value + + is_bind_arg::value + ); + +}; + +} + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : aux::bind_chooser< + aux::bind_count_args< T1,T2,T3,T4,T5 >::value + >::template result_< F,T1,T2,T3,T4,T5 >::type +{ +}; + +BOOST_MPL_AUX_ARITY_SPEC( + 6 + , bind + ) + +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC( + 6 + , bind + ) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp new file mode 100644 index 0000000000..12062b425b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp @@ -0,0 +1,590 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool > +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< + typename T, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > + struct result_ + { + typedef typename apply_wrap5< + T + , U1, U2, U3, U4, U5 + >::type type; + }; +}; + +template< typename T > struct is_bind_template; + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,U1,U2,U3,U4,U5 > +{ +}; + +template< typename T > +struct replace_unnamed_arg_impl +{ + template< typename Arg > struct result_ + { + typedef Arg next; + typedef T type; + }; +}; + +template<> +struct replace_unnamed_arg_impl< arg< -1 > > +{ + template< typename Arg > struct result_ + { + typedef typename next::type next; + typedef Arg type; + }; +}; + +template< typename T, typename Arg > +struct replace_unnamed_arg + : replace_unnamed_arg_impl::template result_ +{ +}; + +template< int arity_ > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag is_bind_helper(bind< F,T1,T2,T3,T4,T5 >*); + +template< int N > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F + > +aux::yes_tag +is_bind_helper(bind0*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +namespace aux { + +template<> +struct bind_chooser<0> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind0 type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1 + > +aux::yes_tag +is_bind_helper(bind1< F,T1 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +namespace aux { + +template<> +struct bind_chooser<1> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind1< F,T1 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2 + > +aux::yes_tag +is_bind_helper(bind2< F,T1,T2 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +namespace aux { + +template<> +struct bind_chooser<2> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind2< F,T1,T2 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3 + > +aux::yes_tag +is_bind_helper(bind3< F,T1,T2,T3 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +namespace aux { + +template<> +struct bind_chooser<3> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind3< F,T1,T2,T3 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +aux::yes_tag +is_bind_helper(bind4< F,T1,T2,T3,T4 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +namespace aux { + +template<> +struct bind_chooser<4> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind4< F,T1,T2,T3,T4 > type; + }; +}; + +} // namespace aux + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +aux::yes_tag +is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +namespace aux { + +template<> +struct bind_chooser<5> +{ + template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > + struct result_ + { + typedef bind5< F,T1,T2,T3,T4,T5 > type; + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_bind_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_bind_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + > +struct bind_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_bind_arg::value + is_bind_arg::value + + is_bind_arg::value + is_bind_arg::value + + is_bind_arg::value + ); + +}; + +} + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : aux::bind_chooser< + aux::bind_count_args< T1,T2,T3,T4,T5 >::value + >::template result_< F,T1,T2,T3,T4,T5 >::type +{ +}; + +BOOST_MPL_AUX_ARITY_SPEC( + 6 + , bind + ) + +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC( + 6 + , bind + ) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp new file mode 100644 index 0000000000..c4a5060ff8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct bind; + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp new file mode 100644 index 0000000000..020d6ba4c6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp @@ -0,0 +1,134 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitand_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitand_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitand_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + + : if_< + + is_na + , bitand_2< N1,N2 > + , bitand_< + bitand_2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitand_2 + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitand_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp new file mode 100644 index 0000000000..0474877675 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp @@ -0,0 +1,134 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitor_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitor_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitor_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + + : if_< + + is_na + , bitor_2< N1,N2 > + , bitor_< + bitor_2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitor_2 + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitor_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp new file mode 100644 index 0000000000..42a9758bbd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp @@ -0,0 +1,134 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitxor_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct bitxor_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct bitxor_2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + + : if_< + + is_na + , bitxor_2< N1,N2 > + , bitxor_< + bitxor_2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct bitxor_2 + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitxor_2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp new file mode 100644 index 0000000000..a0445d9dfd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct deque_chooser; + +} + +namespace aux { + +template<> +struct deque_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef vector0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct deque_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_deque_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_deque_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct deque_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + + is_deque_arg::value + is_deque_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque_impl +{ + typedef aux::deque_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::deque_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque + : aux::deque_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::deque_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp new file mode 100644 index 0000000000..00636dcbf2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct divides_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct divides_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct divides2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + + : if_< + + is_na + , divides2< N1,N2 > + , divides< + divides2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct divides2 + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, divides2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp new file mode 100644 index 0000000000..b14cdda3b9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct equal_to_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct equal_to_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp new file mode 100644 index 0000000000..58066d81f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp @@ -0,0 +1,245 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< int N > +struct fold_chunk; + +template<> struct fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; + }; +}; + +template<> struct fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; + }; +}; + +template<> struct fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; + }; +}; + +template<> struct fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; + }; +}; + +template< int N > +struct fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_step; + +template< + typename Last + , typename State + > +struct fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , fold_null_step< Last,State > + , fold_step< First,Last,State,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_step +{ + typedef fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl + : fold_chunk + ::template result_< First,Last,State,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp new file mode 100644 index 0000000000..bf818731eb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp new file mode 100644 index 0000000000..6fdf8badbe --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp new file mode 100644 index 0000000000..f848eef98c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_equal_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct greater_equal_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp new file mode 100644 index 0000000000..233a1ec30c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp @@ -0,0 +1,166 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C1, bool C2 > +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1, T2 + { + typedef Derived type_; + }; +}; + +template<> +struct inherit2_impl< false,true > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1 + { + typedef T1 type_; + }; +}; + +template<> +struct inherit2_impl< true,false > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T2 + { + typedef T2 type_; + }; +}; + +template<> +struct inherit2_impl< true,true > +{ + template< typename Derived, typename T1, typename T2 > struct result_ + { + typedef T1 type_; + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : aux::inherit2_impl< + is_empty_base::value + , is_empty_base::value + >::template result_< inherit2< T1,T2 >,T1, T2 > +{ + typedef typename inherit2::type_ type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp new file mode 100644 index 0000000000..50ea754f2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp @@ -0,0 +1,245 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< int N > +struct iter_fold_chunk; + +template<> struct iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; + }; +}; + +template<> struct iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; + }; +}; + +template<> struct iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; + }; +}; + +template<> struct iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; + }; +}; + +template< int N > +struct iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_step; + +template< + typename Last + , typename State + > +struct iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , iter_fold_null_step< Last,State > + , iter_fold_step< First,Last,State,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_step +{ + typedef iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > chunk_; + + typedef typename chunk_::state state; + typedef typename chunk_::iterator iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl + : iter_fold_chunk + ::template result_< First,Last,State,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/less.hpp new file mode 100644 index 0000000000..7fb35e1077 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/less.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp new file mode 100644 index 0000000000..206ecdcf93 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_equal_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct less_equal_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/list.hpp new file mode 100644 index 0000000000..e5ea456c9e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/list.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct list_chooser; + +} + +namespace aux { + +template<> +struct list_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef list0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_list_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_list_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct list_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + + is_list_arg::value + is_list_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list_impl +{ + typedef aux::list_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::list_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list + : aux::list_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::list_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp new file mode 100644 index 0000000000..ab25482f55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct list_c_chooser; + +} + +namespace aux { + +template<> +struct list_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct list_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_list_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_list_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct list_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + + is_list_c_arg::value + is_list_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c_impl +{ + typedef aux::list_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::list_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c + : aux::list_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::list_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/map.hpp new file mode 100644 index 0000000000..970e0b7602 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/map.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct map_chooser; + +} + +namespace aux { + +template<> +struct map_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef map0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct map_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_map_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_map_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct map_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + + is_map_arg::value + is_map_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map_impl +{ + typedef aux::map_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::map_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map + : aux::map_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::map_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp new file mode 100644 index 0000000000..7b49450a55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct minus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct minus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct minus2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + + : if_< + + is_na + , minus2< N1,N2 > + , minus< + minus2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct minus2 + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp new file mode 100644 index 0000000000..8badbab5b1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp @@ -0,0 +1,101 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct modulus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct modulus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp new file mode 100644 index 0000000000..d87d8cd11e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct not_equal_to_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct not_equal_to_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/or.hpp new file mode 100644 index 0000000000..3f7394e7cc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/or.hpp @@ -0,0 +1,73 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< bool C_ > struct or_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : true_ + { + }; +}; + +template<> struct or_impl +{ + template< + typename T1, typename T2, typename T3, typename T4 + > + struct result_ + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,false_ > + { + }; +}; + +template<> +struct or_impl + ::result_< false_,false_,false_,false_ > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + >::template result_< T2,T3,T4,T5 > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp new file mode 100644 index 0000000000..a55b24c450 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct plus_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct plus_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct plus2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + + : if_< + + is_na + , plus2< N1,N2 > + , plus< + plus2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct plus2 + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, plus2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp new file mode 100644 index 0000000000..b85880ffdd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp @@ -0,0 +1,116 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { +template< bool > struct quote_impl +{ + template< typename T > struct result_ + : T + { + }; +}; + +template<> struct quote_impl +{ + template< typename T > struct result_ + { + typedef T type; + }; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< aux::has_type< F >::value > + ::template result_< F > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< aux::has_type< F< U1,U2 > >::value > + ::template result_< F< U1,U2 > > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< aux::has_type< F< U1,U2,U3 > >::value > + ::template result_< F< U1,U2,U3 > > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< aux::has_type< F< U1,U2,U3,U4 > >::value > + ::template result_< F< U1,U2,U3,U4 > > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< aux::has_type< F< U1,U2,U3,U4,U5 > >::value > + ::template result_< F< U1,U2,U3,U4,U5 > > + + { + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp new file mode 100644 index 0000000000..7a07414adf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< long N > +struct reverse_fold_chunk; + +template<> struct reverse_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step; + +template< + typename Last + , typename State + > +struct reverse_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_fold_null_step< Last,State > + , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_step +{ + typedef reverse_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl + : reverse_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..39a4057b77 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp @@ -0,0 +1,295 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< long N > +struct reverse_iter_fold_chunk; + +template<> struct reverse_iter_fold_chunk<0> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<2> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<3> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; + }; +}; + +template<> struct reverse_iter_fold_chunk<4> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; + }; +}; + +template< long N > +struct reverse_iter_fold_chunk +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step; + +template< + typename Last + , typename State + > +struct reverse_iter_fold_null_step +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct reverse_iter_fold_chunk< -1 > +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same< First,Last >::type + , reverse_iter_fold_null_step< Last,State > + , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_step +{ + typedef reverse_iter_fold_chunk< -1 >::template result_< + typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl + : reverse_iter_fold_chunk + ::template result_< First,Last,State,BackwardOp,ForwardOp > +{ +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/set.hpp new file mode 100644 index 0000000000..95aaa5cbdf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/set.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct set_chooser; + +} + +namespace aux { + +template<> +struct set_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef set0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_set_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_set_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct set_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + + is_set_arg::value + is_set_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set_impl +{ + typedef aux::set_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::set_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set + : aux::set_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::set_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp new file mode 100644 index 0000000000..1ff34f9032 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct set_c_chooser; + +} + +namespace aux { + +template<> +struct set_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct set_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_set_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_set_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct set_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + + is_set_c_arg::value + is_set_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c_impl +{ + typedef aux::set_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::set_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c + : aux::set_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::set_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp new file mode 100644 index 0000000000..d14a5e4886 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_left_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_left_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp new file mode 100644 index 0000000000..08c4915ebd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_right_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct shift_right_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp new file mode 100644 index 0000000000..1164f0f8c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp @@ -0,0 +1,40 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_< -1 > + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/times.hpp new file mode 100644 index 0000000000..fd773cc842 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/times.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct times_impl< na,integral_c_tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template<> struct times_impl< integral_c_tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +/// forward declaration + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct times2; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + + : if_< + + is_na + , times2< N1,N2 > + , times< + times2< N1,N2 > + , N3, N4, N5 + > + >::type + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1 + , typename N2 + > +struct times2 + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, times2, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp new file mode 100644 index 0000000000..26533dd423 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp @@ -0,0 +1,109 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl +{ + template< typename F, typename Args > struct apply; +}; + +template<> struct unpack_args_impl<0> +{ + template< typename F, typename Args > struct apply + : apply0< + F + > + { + }; +}; + +template<> struct unpack_args_impl<1> +{ + template< typename F, typename Args > struct apply + : apply1< + F + , typename at_c< Args,0 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<2> +{ + template< typename F, typename Args > struct apply + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<3> +{ + template< typename F, typename Args > struct apply + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<4> +{ + template< typename F, typename Args > struct apply + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > + { + }; +}; + +template<> struct unpack_args_impl<5> +{ + template< typename F, typename Args > struct apply + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > + { + }; +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value > + ::template apply< F,Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp new file mode 100644 index 0000000000..a6c7b6219a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp @@ -0,0 +1,556 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct vector_chooser; + +} + +namespace aux { + +template<> +struct vector_chooser<0> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef vector0< + + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<1> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector1< + T0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<2> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector2< + T0, T1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<3> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector3< + T0, T1, T2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<4> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector4< + T0, T1, T2, T3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<5> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector5< + T0, T1, T2, T3, T4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<6> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector6< + T0, T1, T2, T3, T4, T5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<7> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector7< + T0, T1, T2, T3, T4, T5, T6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<8> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector8< + T0, T1, T2, T3, T4, T5, T6, T7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<9> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector9< + T0, T1, T2, T3, T4, T5, T6, T7, T8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<10> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector10< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<11> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector11< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<12> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector12< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<13> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector13< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<14> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector14< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<15> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<16> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<17> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<18> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<19> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_chooser<20> +{ + template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > + struct result_ + { + typedef typename vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< typename T > +struct is_vector_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_vector_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + typename T1, typename T2, typename T3, typename T4, typename T5 + , typename T6, typename T7, typename T8, typename T9, typename T10 + , typename T11, typename T12, typename T13, typename T14, typename T15 + , typename T16, typename T17, typename T18, typename T19, typename T20 + > +struct vector_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + + is_vector_arg::value + is_vector_arg::value + ); + +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector_impl +{ + typedef aux::vector_count_args< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + > arg_num_; + + typedef typename aux::vector_chooser< arg_num_::value > + ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +} // namespace aux + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector + : aux::vector_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type +{ + typedef typename aux::vector_impl< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp new file mode 100644 index 0000000000..6cf7b449b7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp @@ -0,0 +1,534 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template< int N > +struct vector_c_chooser; + +} + +namespace aux { + +template<> +struct vector_c_chooser<0> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector0_c< + T + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<1> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector1_c< + T, C0 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<2> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector2_c< + T, C0, C1 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<3> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector3_c< + T, C0, C1, C2 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<4> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector4_c< + T, C0, C1, C2, C3 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<5> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector5_c< + T, C0, C1, C2, C3, C4 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<6> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector6_c< + T, C0, C1, C2, C3, C4, C5 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<7> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector7_c< + T, C0, C1, C2, C3, C4, C5, C6 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<8> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector8_c< + T, C0, C1, C2, C3, C4, C5, C6, C7 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<9> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector9_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<10> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector10_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<11> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector11_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<12> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector12_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<13> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector13_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<14> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<15> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<16> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<17> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<18> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<19> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template<> +struct vector_c_chooser<20> +{ + template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > + struct result_ + { + typedef typename vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; + + }; +}; + +} // namespace aux + +namespace aux { + +template< long C > +struct is_vector_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> +struct is_vector_c_arg +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template< + long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 + , long C9, long C10, long C11, long C12, long C13, long C14, long C15 + , long C16, long C17, long C18, long C19, long C20 + > +struct vector_c_count_args +{ + BOOST_STATIC_CONSTANT(int, value = + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + + is_vector_c_arg::value + is_vector_c_arg::value + ); + +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c_impl +{ + typedef aux::vector_c_count_args< + C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + > arg_num_; + + typedef typename aux::vector_c_chooser< arg_num_::value > + ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +} // namespace aux + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c + : aux::vector_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type +{ + typedef typename aux::vector_c_impl< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 + >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/and.hpp new file mode 100644 index 0000000000..010ad1fc84 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/and.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , and_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp new file mode 100644 index 0000000000..e08eaccf03 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 1 + , apply0 + , (F ) + ) +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 2 + , apply1 + , (F, T1) + ) +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , apply2 + , (F, T1, T2) + ) +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , apply3 + , (F, T1, T2, T3) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , apply4 + , (F, T1, T2, T3, T4) + ) +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , apply5 + , (F, T1, T2, T3, T4, T5) + ) +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp new file mode 100644 index 0000000000..34d51a1a58 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp @@ -0,0 +1,84 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + + : F::template apply< > +{ +}; + +template< typename F > +struct apply_wrap0< F,true_ > + : F::apply +{ +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + + : F::template apply +{ +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + + : F::template apply< T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + + : F::template apply< T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + + : F::template apply< T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + + : F::template apply< T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp new file mode 100644 index 0000000000..095b84dd9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp @@ -0,0 +1,369 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp new file mode 100644 index 0000000000..28914408ab --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp @@ -0,0 +1,466 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp new file mode 100644 index 0000000000..c4a5060ff8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct bind; + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp new file mode 100644 index 0000000000..282771bce5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp @@ -0,0 +1,157 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitand_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitand_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 & n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitand_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp new file mode 100644 index 0000000000..bc9c1989db --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp @@ -0,0 +1,157 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitor_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 | n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitor_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp new file mode 100644 index 0000000000..76ce540b4e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp @@ -0,0 +1,157 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , bitxor_ + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct bitxor_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 ^ n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::bitxor_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp new file mode 100644 index 0000000000..9bc7fb192a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp @@ -0,0 +1,156 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , divides + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct divides_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 / n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::divides_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp new file mode 100644 index 0000000000..fa2dc4a25a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp @@ -0,0 +1,98 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp new file mode 100644 index 0000000000..bf818731eb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp new file mode 100644 index 0000000000..faa3f2ba9a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp @@ -0,0 +1,98 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp new file mode 100644 index 0000000000..392d142d92 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp @@ -0,0 +1,98 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp new file mode 100644 index 0000000000..00f31c4226 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 3 + , inherit3 + , ( T1, T2, T3) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , inherit4 + , ( T1, T2, T3, T4) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , inherit5 + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp new file mode 100644 index 0000000000..890a198a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; + BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/less.hpp new file mode 100644 index 0000000000..6451680fe8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/less.hpp @@ -0,0 +1,98 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > + BOOST_MPL_AUX_VALUE_WKND(N1)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp new file mode 100644 index 0000000000..00ae0d3ecb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp @@ -0,0 +1,98 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp new file mode 100644 index 0000000000..bb67c59a52 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp @@ -0,0 +1,156 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , minus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct minus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 - n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::minus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp new file mode 100644 index 0000000000..6fd0cab37a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp @@ -0,0 +1,111 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct modulus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 % n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::modulus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp new file mode 100644 index 0000000000..7c940a5b07 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp @@ -0,0 +1,98 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + { + BOOST_STATIC_CONSTANT(bool, value = + ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) + ); + typedef bool_ type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/or.hpp new file mode 100644 index 0000000000..31e1aaa4e6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/or.hpp @@ -0,0 +1,69 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , or_ + , ( T1, T2, T3, T4, T5) + ) +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp new file mode 100644 index 0000000000..cecead75ab --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp @@ -0,0 +1,156 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , plus + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct plus_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 + n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::plus_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp new file mode 100644 index 0000000000..e7a7f00196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp new file mode 100644 index 0000000000..c468684c91 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..658f92a7c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp new file mode 100644 index 0000000000..7ef4672522 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp @@ -0,0 +1,110 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct shift_left_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n << s)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + : aux::shift_left_wknd< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp new file mode 100644 index 0000000000..91a98f7385 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp @@ -0,0 +1,110 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct shift_right_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n >> s)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + : aux::shift_right_wknd< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp new file mode 100644 index 0000000000..1164f0f8c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp @@ -0,0 +1,40 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_< -1 > + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/times.hpp new file mode 100644 index 0000000000..d019b57247 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/times.hpp @@ -0,0 +1,156 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 5 + , times + , ( N1, N2, N3, N4, N5 ) + ) +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { + +namespace aux { +template< typename T, T n1, T n2 > +struct times_wknd +{ + BOOST_STATIC_CONSTANT(T, value = (n1 * n2)); + typedef integral_c< T,value > type; +}; + +} + +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + : aux::times_wknd< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , N1::value + , N2::value + >::type + + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp new file mode 100644 index 0000000000..2194ce9d11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value,F, Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp new file mode 100644 index 0000000000..26de94cea1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_backward; +template<> +struct advance_backward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_backward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_backward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_backward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_backward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename prior::type iter1; + typedef typename prior::type iter2; + typedef typename prior::type iter3; + typedef typename prior::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_backward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_backward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_backward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp new file mode 100644 index 0000000000..b137cc72af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< long N > struct advance_forward; +template<> +struct advance_forward<0> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef iter0 type; + }; +}; + +template<> +struct advance_forward<1> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef iter1 type; + }; +}; + +template<> +struct advance_forward<2> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef iter2 type; + }; +}; + +template<> +struct advance_forward<3> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef iter3 type; + }; +}; + +template<> +struct advance_forward<4> +{ + template< typename Iterator > struct apply + { + typedef Iterator iter0; + typedef typename next::type iter1; + typedef typename next::type iter2; + typedef typename next::type iter3; + typedef typename next::type iter4; + typedef iter4 type; + }; +}; + +template< long N > +struct advance_forward +{ + template< typename Iterator > struct apply + { + typedef typename apply_wrap1< + advance_forward<4> + , Iterator + >::type chunk_result_; + + typedef typename apply_wrap1< + advance_forward<( + (N - 4) < 0 + ? 0 + : N - 4 + )> + , chunk_result_ + >::type type; + }; +}; + +}}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/and.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/and.hpp new file mode 100644 index 0000000000..163913f81a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/and.hpp @@ -0,0 +1,64 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply.hpp new file mode 100644 index 0000000000..89d9e4b4ea --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply.hpp @@ -0,0 +1,139 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp new file mode 100644 index 0000000000..b2ed5d5130 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp new file mode 100644 index 0000000000..34d51a1a58 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp @@ -0,0 +1,84 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + + : F::template apply< > +{ +}; + +template< typename F > +struct apply_wrap0< F,true_ > + : F::apply +{ +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + + : F::template apply +{ +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + + : F::template apply< T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + + : F::template apply< T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + + : F::template apply< T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + + : F::template apply< T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/arg.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/arg.hpp new file mode 100644 index 0000000000..6f2f8a8070 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp new file mode 100644 index 0000000000..b0702324aa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp @@ -0,0 +1,440 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; + typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; + + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +template< + template< typename T1, typename T2, typename T3 > class F, typename Tag + > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct eval_if; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< eval_if,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; + typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; + typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; + typedef typename eval_if< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bind.hpp new file mode 100644 index 0000000000..0e9513a649 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bind.hpp @@ -0,0 +1,561 @@ + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename T, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg +{ + typedef T type; +}; + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg< -1 >, Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +template< + int N, typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > +{ + typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > +{ + typedef bind< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +template< + typename F + > +struct bind0 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + public: + typedef typename apply_wrap0< + f_ + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind0, U1, U2, U3, U4, U5 + > +{ + typedef bind0 f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(1, bind0) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) + +template< + typename F + > +struct bind< F,na,na,na,na,na > + : bind0 +{ +}; + +template< + typename F, typename T1 + > +struct bind1 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + public: + typedef typename apply_wrap1< + f_ + , typename t1::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename U1, typename U2, typename U3 + , typename U4, typename U5 + > +struct resolve_bind_arg< + bind1< F,T1 >, U1, U2, U3, U4, U5 + > +{ + typedef bind1< F,T1 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(2, bind1) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) + +template< + typename F, typename T1 + > +struct bind< F,T1,na,na,na,na > + : bind1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct bind2 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + public: + typedef typename apply_wrap2< + f_ + , typename t1::type, typename t2::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename U1, typename U2 + , typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind2< F,T1,T2 >, U1, U2, U3, U4, U5 + > +{ + typedef bind2< F,T1,T2 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(3, bind2) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) + +template< + typename F, typename T1, typename T2 + > +struct bind< F,T1,T2,na,na,na > + : bind2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + public: + typedef typename apply_wrap3< + f_ + , typename t1::type, typename t2::type, typename t3::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename U1 + , typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 + > +{ + typedef bind3< F,T1,T2,T3 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(4, bind3) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind< F,T1,T2,T3,na,na > + : bind3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + public: + typedef typename apply_wrap4< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename U1, typename U2, typename U3, typename U4, typename U5 + > +struct resolve_bind_arg< + bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 + > +{ + typedef bind4< F,T1,T2,T3,T4 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(5, bind4) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind< F,T1,T2,T3,T4,na > + : bind4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5 +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; + /// + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef aux::replace_unnamed_arg< T4,n4 > r4; + typedef typename r4::type a4; + typedef typename r4::next n5; + typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; + /// + typedef aux::replace_unnamed_arg< T5,n5 > r5; + typedef typename r5::type a5; + typedef typename r5::next n6; + typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; + /// + public: + typedef typename apply_wrap5< + f_ + , typename t1::type, typename t2::type, typename t3::type + , typename t4::type, typename t5::type + >::type type; + + }; +}; + +namespace aux { + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename U1, typename U2, typename U3, typename U4 + , typename U5 + > +struct resolve_bind_arg< + bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 + > +{ + typedef bind5< F,T1,T2,T3,T4,T5 > f_; + typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; +}; + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(6, bind5) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind + : bind5< F,T1,T2,T3,T4,T5 > +{ +}; + +/// if_/eval_if specializations +template< template< typename T1, typename T2, typename T3 > class F, typename Tag > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct if_; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< if_,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename if_< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +template< + template< typename T1, typename T2, typename T3 > class F, typename Tag + > +struct quote3; + +template< typename T1, typename T2, typename T3 > struct eval_if; + +template< + typename Tag, typename T1, typename T2, typename T3 + > +struct bind3< + quote3< eval_if,Tag > + , T1, T2, T3 + > +{ + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + private: + typedef mpl::arg<1> n1; + typedef aux::replace_unnamed_arg< T1,n1 > r1; + typedef typename r1::type a1; + typedef typename r1::next n2; + typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; + /// + typedef aux::replace_unnamed_arg< T2,n2 > r2; + typedef typename r2::type a2; + typedef typename r2::next n3; + typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; + /// + typedef aux::replace_unnamed_arg< T3,n3 > r3; + typedef typename r3::type a3; + typedef typename r3::next n4; + typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; + /// + typedef typename eval_if< + typename t1::type + , t2, t3 + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp new file mode 100644 index 0000000000..c4a5060ff8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct bind; + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitand.hpp new file mode 100644 index 0000000000..ee40fb3d3f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitand.hpp @@ -0,0 +1,142 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitand.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitand_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitand_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitand_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitand_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitand_ + : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitand_< N1,N2,N3,N4,na > + + : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitand_< N1,N2,N3,na,na > + + : bitand_< bitand_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitand_< N1,N2,na,na,na > + : bitand_impl< + typename bitand_tag::type + , typename bitand_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitand_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitand_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + & BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitor.hpp new file mode 100644 index 0000000000..1e28d3b07e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitor.hpp @@ -0,0 +1,142 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitor_ + : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitor_< N1,N2,N3,N4,na > + + : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitor_< N1,N2,N3,na,na > + + : bitor_< bitor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitor_< N1,N2,na,na,na > + : bitor_impl< + typename bitor_tag::type + , typename bitor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + | BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitxor.hpp new file mode 100644 index 0000000000..2ba879d67b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/bitxor.hpp @@ -0,0 +1,142 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/bitxor.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct bitxor_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct bitxor_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct bitxor_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct bitxor_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct bitxor_ + : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct bitxor_< N1,N2,N3,N4,na > + + : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct bitxor_< N1,N2,N3,na,na > + + : bitxor_< bitxor_< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct bitxor_< N1,N2,na,na,na > + : bitxor_impl< + typename bitxor_tag::type + , typename bitxor_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , bitxor_ + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) + +}} + +namespace boost { namespace mpl { +template<> +struct bitxor_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/deque.hpp new file mode 100644 index 0000000000..de67398a37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/deque.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/deque.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct deque; + +template< + + > +struct deque< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct deque< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct deque< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct deque< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct deque< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct deque< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct deque< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct deque< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct deque + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/divides.hpp new file mode 100644 index 0000000000..f365d62dfa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/divides.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/divides.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct divides_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct divides_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct divides_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct divides_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct divides + : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct divides< N1,N2,N3,N4,na > + + : divides< divides< divides< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct divides< N1,N2,N3,na,na > + + : divides< divides< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct divides< N1,N2,na,na,na > + : divides_impl< + typename divides_tag::type + , typename divides_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , divides + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) + +}} + +namespace boost { namespace mpl { +template<> +struct divides_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + / BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/equal_to.hpp new file mode 100644 index 0000000000..bbc6bf0dc1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/equal_to.hpp @@ -0,0 +1,92 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct equal_to + + : equal_to_impl< + typename equal_to_tag::type + , typename equal_to_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp new file mode 100644 index 0000000000..9e7a29300d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl +{ + typedef fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,First,Last,State,ForwardOp > + : fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp new file mode 100644 index 0000000000..bf818731eb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/greater.hpp new file mode 100644 index 0000000000..38c8bb3add --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/greater.hpp @@ -0,0 +1,92 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater + + : greater_impl< + typename greater_tag::type + , typename greater_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp new file mode 100644 index 0000000000..2aa8370f0f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp @@ -0,0 +1,92 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/greater_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct greater_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct greater_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct greater_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct greater_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct greater_equal + + : greater_equal_impl< + typename greater_equal_tag::type + , typename greater_equal_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct greater_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/inherit.hpp new file mode 100644 index 0000000000..8b34e718c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/inherit.hpp @@ -0,0 +1,125 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/inherit.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; +}; + +template< typename T1 > +struct inherit2< T1,empty_base > +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) +}; + +template< typename T2 > +struct inherit2< empty_base,T2 > +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) +}; + +template<> +struct inherit2< empty_base,empty_base > +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +template< + typename T1 = na, typename T2 = na, typename T3 = na + > +struct inherit3 + : inherit2< + typename inherit2< + T1, T2 + >::type + , T3 + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(3, inherit3) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + > +struct inherit4 + : inherit2< + typename inherit3< + T1, T2, T3 + >::type + , T4 + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(4, inherit4) + +template< + typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na + , typename T5 = na + > +struct inherit5 + : inherit2< + typename inherit4< + T1, T2, T3, T4 + >::type + , T5 + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(5, inherit5) + +/// primary template + +template< + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + > +struct inherit + : inherit5< T1,T2,T3,T4,T5 > +{ +}; + +template<> +struct inherit< na,na,na,na,na > +{ + template< + + typename T1 = empty_base, typename T2 = empty_base + , typename T3 = empty_base, typename T4 = empty_base + , typename T5 = empty_base + + > + struct apply + : inherit< T1,T2,T3,T4,T5 > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp new file mode 100644 index 0000000000..695179584d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp @@ -0,0 +1,133 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +template< typename Iterator, typename State > +struct iter_fold_if_null_step +{ + typedef State state; + typedef Iterator iterator; +}; + +template< bool > +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef typename apply2< StateOp,State,Iterator >::type state; + typedef typename IteratorOp::type iterator; + }; +}; + +template<> +struct iter_fold_if_step_impl +{ + template< + typename Iterator + , typename State + , typename StateOp + , typename IteratorOp + > + struct result_ + { + typedef State state; + typedef Iterator iterator; + }; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename Predicate + > +struct iter_fold_if_forward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename BackwardOp + , typename Predicate + > +struct iter_fold_if_backward_step +{ + typedef typename apply2< Predicate,State,Iterator >::type not_last; + typedef typename iter_fold_if_step_impl< + BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value + >::template result_< Iterator,State,BackwardOp, identity > impl_; + + typedef typename impl_::state state; + typedef typename impl_::iterator iterator; +}; + +template< + typename Iterator + , typename State + , typename ForwardOp + , typename ForwardPredicate + , typename BackwardOp + , typename BackwardPredicate + > +struct iter_fold_if_impl +{ + private: + typedef iter_fold_if_null_step< Iterator,State > forward_step0; + typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; + typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; + typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; + typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; + + + typedef typename if_< + typename forward_step4::not_last + , iter_fold_if_impl< + typename forward_step4::iterator + , typename forward_step4::state + , ForwardOp + , ForwardPredicate + , BackwardOp + , BackwardPredicate + > + , iter_fold_if_null_step< + typename forward_step4::iterator + , typename forward_step4::state + > + >::type backward_step4; + + typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; + typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; + typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; + typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; + + + public: + typedef typename backward_step0::state state; + typedef typename backward_step4::iterator iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp new file mode 100644 index 0000000000..805790e86d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp @@ -0,0 +1,180 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 0,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 1,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + + + typedef state1 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 2,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + + + typedef state2 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 3,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + + + typedef state3 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< 4,First,Last,State,ForwardOp > +{ + typedef First iter0; + typedef State state0; + typedef typename apply2< ForwardOp,state0,iter0 >::type state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,state1,iter1 >::type state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,state2,iter2 >::type state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,state3,iter3 >::type state4; + typedef typename mpl::next::type iter4; + + + typedef state4 state; + typedef iter4 iterator; +}; + +template< + int N + , typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl +{ + typedef iter_fold_impl< + 4 + , First + , Last + , State + , ForwardOp + > chunk_; + + typedef iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , typename chunk_::iterator + , Last + , typename chunk_::state + , ForwardOp + > res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,First,Last,State,ForwardOp > + : iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , ForwardOp + > +{ +}; + +template< + typename Last + , typename State + , typename ForwardOp + > +struct iter_fold_impl< -1,Last,Last,State,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp new file mode 100644 index 0000000000..f8f109c2bd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp @@ -0,0 +1,228 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +template< typename Arity > struct lambda_impl +{ + template< typename T, typename Tag, typename Protect > struct result_ + { + typedef T type; + typedef is_placeholder is_le; + }; +}; + +template<> struct lambda_impl< int_<1> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef typename l1::is_le is_le1; + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value + > is_le; + + typedef bind1< + typename F::rebind + , typename l1::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<2> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value + > is_le; + + typedef bind2< + typename F::rebind + , typename l1::type, typename l2::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<3> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value + > is_le; + + typedef bind3< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<4> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value + > is_le; + + typedef bind4< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +template<> struct lambda_impl< int_<5> > +{ + template< typename F, typename Tag, typename Protect > struct result_ + { + typedef lambda< typename F::arg1, Tag, false_ > l1; + typedef lambda< typename F::arg2, Tag, false_ > l2; + typedef lambda< typename F::arg3, Tag, false_ > l3; + typedef lambda< typename F::arg4, Tag, false_ > l4; + typedef lambda< typename F::arg5, Tag, false_ > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef aux::lambda_or< + BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value + > is_le; + + typedef bind5< + typename F::rebind + , typename l1::type, typename l2::type, typename l3::type + , typename l4::type, typename l5::type + > bind_; + + typedef typename if_< + is_le + , if_< Protect, mpl::protect, bind_ > + , identity + >::type type_; + + typedef typename type_::type type; + }; +}; + +} // namespace aux + +template< + typename T + , typename Tag + , typename Protect + > +struct lambda +{ + /// Metafunction forwarding confuses MSVC 6.x + typedef typename aux::template_arity::type arity_; + typedef typename aux::lambda_impl + ::template result_< T,Tag,Protect > l_; + + typedef typename l_::type type; + typedef typename l_::is_le is_le; +}; + +BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/less.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/less.hpp new file mode 100644 index 0000000000..928d0e3087 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/less.hpp @@ -0,0 +1,92 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less + + : less_impl< + typename less_tag::type + , typename less_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/less_equal.hpp new file mode 100644 index 0000000000..364cd967a7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/less_equal.hpp @@ -0,0 +1,92 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/less_equal.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct less_equal_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct less_equal_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct less_equal_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct less_equal_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct less_equal + + : less_equal_impl< + typename less_equal_tag::type + , typename less_equal_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) + +}} + +namespace boost { namespace mpl { + +template<> +struct less_equal_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/list.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/list.hpp new file mode 100644 index 0000000000..4e8ad53d21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/list.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct list; + +template< + + > +struct list< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list0< > +{ + typedef list0< >::type type; +}; + +template< + typename T0 + > +struct list< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list1 +{ + typedef typename list1::type type; +}; + +template< + typename T0, typename T1 + > +struct list< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list2< T0,T1 > +{ + typedef typename list2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list3< T0,T1,T2 > +{ + typedef typename list3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list4< T0,T1,T2,T3 > +{ + typedef typename list4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list5< T0,T1,T2,T3,T4 > +{ + typedef typename list5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : list8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : list15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : list16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : list17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : list18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : list19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list + : list20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/list_c.hpp new file mode 100644 index 0000000000..0b48a7f8e1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/list_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct list_c; + +template< + typename T + > +struct list_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list0_c +{ + typedef typename list0_c::type type; +}; + +template< + typename T, long C0 + > +struct list_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list1_c< T,C0 > +{ + typedef typename list1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct list_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list2_c< T,C0,C1 > +{ + typedef typename list2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct list_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list3_c< T,C0,C1,C2 > +{ + typedef typename list3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct list_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list4_c< T,C0,C1,C2,C3 > +{ + typedef typename list4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct list_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : list16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : list17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : list18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct list_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : list19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct list_c + : list20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/map.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/map.hpp new file mode 100644 index 0000000000..837e013771 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/map.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct map; + +template< + + > +struct map< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map0< > +{ + typedef map0< >::type type; +}; + +template< + typename T0 + > +struct map< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map1 +{ + typedef typename map1::type type; +}; + +template< + typename T0, typename T1 + > +struct map< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map2< T0,T1 > +{ + typedef typename map2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct map< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map3< T0,T1,T2 > +{ + typedef typename map3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct map< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map4< T0,T1,T2,T3 > +{ + typedef typename map4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct map< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map5< T0,T1,T2,T3,T4 > +{ + typedef typename map5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct map< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : map8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : map15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : map16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : map17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : map18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct map< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : map19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct map + : map20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/minus.hpp new file mode 100644 index 0000000000..0b8b5ceeb7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/minus.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/minus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct minus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct minus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct minus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct minus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct minus + : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct minus< N1,N2,N3,N4,na > + + : minus< minus< minus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct minus< N1,N2,N3,na,na > + + : minus< minus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct minus< N1,N2,na,na,na > + : minus_impl< + typename minus_tag::type + , typename minus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , minus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) + +}} + +namespace boost { namespace mpl { +template<> +struct minus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + - BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/modulus.hpp new file mode 100644 index 0000000000..6a64e49a81 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/modulus.hpp @@ -0,0 +1,99 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/modulus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct modulus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct modulus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct modulus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct modulus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct modulus + + : modulus_impl< + typename modulus_tag::type + , typename modulus_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) + +}} + +namespace boost { namespace mpl { +template<> +struct modulus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + % BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp new file mode 100644 index 0000000000..c08d7f06d7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp @@ -0,0 +1,92 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/not_equal_to.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct not_equal_to_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct not_equal_to_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct not_equal_to_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct not_equal_to_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct not_equal_to + + : not_equal_to_impl< + typename not_equal_to_tag::type + , typename not_equal_to_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) + +}} + +namespace boost { namespace mpl { + +template<> +struct not_equal_to_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/or.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/or.hpp new file mode 100644 index 0000000000..986b2e0ea4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/or.hpp @@ -0,0 +1,64 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/placeholders.hpp new file mode 100644 index 0000000000..ff97364b9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/plus.hpp new file mode 100644 index 0000000000..ed2e432dc8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/plus.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/plus.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct plus_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct plus_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct plus_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct plus_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct plus + : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct plus< N1,N2,N3,N4,na > + + : plus< plus< plus< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct plus< N1,N2,N3,na,na > + + : plus< plus< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct plus< N1,N2,na,na,na > + : plus_impl< + typename plus_tag::type + , typename plus_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , plus + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) + +}} + +namespace boost { namespace mpl { +template<> +struct plus_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + + BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/quote.hpp new file mode 100644 index 0000000000..d7d0420e4d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/quote.hpp @@ -0,0 +1,123 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename T, bool has_type_ > +struct quote_impl + : T +{ +}; + +template< typename T > +struct quote_impl< T,false > +{ + typedef T type; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< + F + , aux::has_type< F >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< + F< U1,U2 > + , aux::has_type< F< U1,U2 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< + F< U1,U2,U3 > + , aux::has_type< F< U1,U2,U3 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4 > + , aux::has_type< F< U1,U2,U3,U4 > >::value + > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4,U5 > + , aux::has_type< F< U1,U2,U3,U4,U5 > >::value + > + + { + }; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp new file mode 100644 index 0000000000..c468684c91 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; + typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; + typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; + typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2::type>::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , typename deref::type + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..658f92a7c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp @@ -0,0 +1,231 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef fwd_state0 bkwd_state0; + typedef bkwd_state0 state; + typedef iter0 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + + + typedef fwd_state1 bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + typedef bkwd_state0 state; + typedef iter1 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + + + typedef fwd_state2 bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter2 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + + + typedef fwd_state3 bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter3 iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef fwd_state4 bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef iter4 iterator; +}; + +template< + long N + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl +{ + typedef First iter0; + typedef State fwd_state0; + typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; + typedef typename mpl::next::type iter1; + typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; + typedef typename mpl::next::type iter2; + typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; + typedef typename mpl::next::type iter3; + typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; + typedef typename mpl::next::type iter4; + + + typedef reverse_iter_fold_impl< + ( (N - 4) < 0 ? 0 : N - 4 ) + , iter4 + , Last + , fwd_state4 + , BackwardOp + , ForwardOp + > nested_chunk; + + typedef typename nested_chunk::state bkwd_state4; + typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; + typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; + typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; + typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; + + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > +{ + typedef reverse_iter_fold_impl< + -1 + , typename mpl::next::type + , Last + , typename apply2< ForwardOp,State,First >::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , First + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > +{ + typedef State state; + typedef Last iterator; +}; + +}}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/set.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/set.hpp new file mode 100644 index 0000000000..5721922e11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/set.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct set; + +template< + + > +struct set< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set0< > +{ + typedef set0< >::type type; +}; + +template< + typename T0 + > +struct set< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set1 +{ + typedef typename set1::type type; +}; + +template< + typename T0, typename T1 + > +struct set< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set2< T0,T1 > +{ + typedef typename set2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set3< T0,T1,T2 > +{ + typedef typename set3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set4< T0,T1,T2,T3 > +{ + typedef typename set4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set5< T0,T1,T2,T3,T4 > +{ + typedef typename set5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : set8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : set15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : set16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : set17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : set18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : set19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set + : set20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/set_c.hpp new file mode 100644 index 0000000000..cbeb932c13 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/set_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct set_c; + +template< + typename T + > +struct set_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set0_c +{ + typedef typename set0_c::type type; +}; + +template< + typename T, long C0 + > +struct set_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set1_c< T,C0 > +{ + typedef typename set1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct set_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set2_c< T,C0,C1 > +{ + typedef typename set2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct set_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set3_c< T,C0,C1,C2 > +{ + typedef typename set3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct set_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set4_c< T,C0,C1,C2,C3 > +{ + typedef typename set4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct set_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : set16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : set17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : set18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct set_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : set19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct set_c + : set20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/shift_left.hpp new file mode 100644 index 0000000000..cf9c837d6a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/shift_left.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_left.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_left_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_left_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_left_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_left_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_left + + : shift_left_impl< + typename shift_left_tag::type + , typename shift_left_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_left_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + << BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/shift_right.hpp new file mode 100644 index 0000000000..477229f24e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/shift_right.hpp @@ -0,0 +1,97 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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) +// + +// Preprocessed version of "boost/mpl/shift_right.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct shift_right_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct shift_right_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct shift_right_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct shift_right_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct shift_right + + : shift_right_impl< + typename shift_right_tag::type + , typename shift_right_tag::type + >::template apply< N1,N2 >::type +{ +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) + +}} + +namespace boost { namespace mpl { +template<> +struct shift_right_impl< integral_c_tag,integral_c_tag > +{ + template< typename N, typename S > struct apply + + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + >> BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/template_arity.hpp new file mode 100644 index 0000000000..a23fc23846 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/template_arity.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/times.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/times.hpp new file mode 100644 index 0000000000..ca88d405f0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/times.hpp @@ -0,0 +1,141 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/times.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename Tag1 + , typename Tag2 + > +struct times_impl + : if_c< + ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) + > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) + ) + + , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > + , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > + >::type +{ +}; + +/// for Digital Mars C++/compilers with no CTPS/TTP support +template<> struct times_impl< na,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< na,Tag > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename Tag > struct times_impl< Tag,na > +{ + template< typename U1, typename U2 > struct apply + { + typedef apply type; + BOOST_STATIC_CONSTANT(int, value = 0); + }; +}; + +template< typename T > struct times_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + , typename N3 = na, typename N4 = na, typename N5 = na + > +struct times + : times< times< times< times< N1,N2 >, N3>, N4>, N5> +{ +}; + +template< + typename N1, typename N2, typename N3, typename N4 + > +struct times< N1,N2,N3,N4,na > + + : times< times< times< N1,N2 >, N3>, N4> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, N4, na ) + ) +}; + +template< + typename N1, typename N2, typename N3 + > +struct times< N1,N2,N3,na,na > + + : times< times< N1,N2 >, N3> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, N3, na, na ) + ) +}; + +template< + typename N1, typename N2 + > +struct times< N1,N2,na,na,na > + : times_impl< + typename times_tag::type + , typename times_tag::type + >::template apply< N1,N2 >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( + 5 + , times + , ( N1, N2, na, na, na ) + ) + +}; + +BOOST_MPL_AUX_NA_SPEC2(2, 5, times) + +}} + +namespace boost { namespace mpl { +template<> +struct times_impl< integral_c_tag,integral_c_tag > +{ + template< typename N1, typename N2 > struct apply + + : integral_c< + typename aux::largest_int< + typename N1::value_type + , typename N2::value_type + >::type + , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + * BOOST_MPL_AUX_VALUE_WKND(N2)::value + ) + > + { + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp new file mode 100644 index 0000000000..2194ce9d11 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp @@ -0,0 +1,94 @@ + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/unpack_args.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< int size, typename F, typename Args > +struct unpack_args_impl; + +template< typename F, typename Args > +struct unpack_args_impl< 0,F,Args > + : apply0< + F + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 1,F,Args > + : apply1< + F + , typename at_c< Args,0 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 2,F,Args > + : apply2< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 3,F,Args > + : apply3< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 4,F,Args > + : apply4< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + > +{ +}; + +template< typename F, typename Args > +struct unpack_args_impl< 5,F,Args > + : apply5< + F + , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type + , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type + , typename at_c< Args,4 >::type + > +{ +}; + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply + + : aux::unpack_args_impl< size::value,F, Args > + + { + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/vector.hpp new file mode 100644 index 0000000000..bfa9565a53 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/vector.hpp @@ -0,0 +1,323 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na + , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na + , typename T12 = na, typename T13 = na, typename T14 = na + , typename T15 = na, typename T16 = na, typename T17 = na + , typename T18 = na, typename T19 = na + > +struct vector; + +template< + + > +struct vector< + na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector0< > +{ + typedef vector0< >::type type; +}; + +template< + typename T0 + > +struct vector< + T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector1 +{ + typedef typename vector1::type type; +}; + +template< + typename T0, typename T1 + > +struct vector< + T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector2< T0,T1 > +{ + typedef typename vector2< T0,T1 >::type type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector< + T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector3< T0,T1,T2 > +{ + typedef typename vector3< T0,T1,T2 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector< + T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector4< T0,T1,T2,T3 > +{ + typedef typename vector4< T0,T1,T2,T3 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector< + T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector5< T0,T1,T2,T3,T4 > +{ + typedef typename vector5< T0,T1,T2,T3,T4 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector< + T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector6< T0,T1,T2,T3,T4,T5 > +{ + typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector7< T0,T1,T2,T3,T4,T5,T6 > +{ + typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na + , na, na, na + > + : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > +{ + typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na + , na, na, na + > + : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > +{ + typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na + , na, na, na + > + : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > +{ + typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na + , na, na, na + > + : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > +{ + typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na + , na, na, na, na + > + : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > +{ + typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na + , na, na, na, na + > + : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > +{ + typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na + , na, na, na, na + > + : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > +{ + typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na + , na, na, na, na + > + : vector15< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + > +{ + typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, na, na, na, na + > + : vector16< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15 + > +{ + typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, na, na, na + > + : vector17< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16 + > +{ + typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, na, na + > + : vector18< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17 + > +{ + typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, na + > + : vector19< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18 + > +{ + typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector + : vector20< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 + , T15, T16, T17, T18, T19 + > +{ + typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/vector_c.hpp new file mode 100644 index 0000000000..840c2e1ab9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessed/plain/vector_c.hpp @@ -0,0 +1,328 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX + , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX + , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX + , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX + , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX + , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX + , long C18 = LONG_MAX, long C19 = LONG_MAX + > +struct vector_c; + +template< + typename T + > +struct vector_c< + T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector0_c +{ + typedef typename vector0_c::type type; +}; + +template< + typename T, long C0 + > +struct vector_c< + T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector1_c< T,C0 > +{ + typedef typename vector1_c< T,C0 >::type type; +}; + +template< + typename T, long C0, long C1 + > +struct vector_c< + T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector2_c< T,C0,C1 > +{ + typedef typename vector2_c< T,C0,C1 >::type type; +}; + +template< + typename T, long C0, long C1, long C2 + > +struct vector_c< + T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector3_c< T,C0,C1,C2 > +{ + typedef typename vector3_c< T,C0,C1,C2 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3 + > +struct vector_c< + T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector4_c< T,C0,C1,C2,C3 > +{ + typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4 + > +struct vector_c< + T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector5_c< T,C0,C1,C2,C3,C4 > +{ + typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector6_c< T,C0,C1,C2,C3,C4,C5 > +{ + typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX + > + : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > +{ + typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX + > + : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > +{ + typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > +{ + typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + , LONG_MAX + > + : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > +{ + typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > +{ + typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > +{ + typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > +{ + typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector14_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 + > +{ + typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector15_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + > +{ + typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector16_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15 + > +{ + typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX + > + : vector17_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16 + > +{ + typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, LONG_MAX, LONG_MAX + > + : vector18_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17 + > +{ + typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; +}; + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18 + > +struct vector_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, LONG_MAX + > + : vector19_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18 + > +{ + typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; +}; + +/// primary template (not a specialization!) + +template< + typename T, long C0, long C1, long C2, long C3, long C4, long C5 + , long C6, long C7, long C8, long C9, long C10, long C11, long C12 + , long C13, long C14, long C15, long C16, long C17, long C18, long C19 + > +struct vector_c + : vector20_c< + T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 + , C15, C16, C17, C18, C19 + > +{ + typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; +}; + +}} + diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/add.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/add.hpp new file mode 100644 index 0000000000..b358915119 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/add.hpp @@ -0,0 +1,65 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_ADD_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_ADD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/add.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.6 $ + +#include + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include + +#if defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) +# include + +# define BOOST_MPL_PP_ADD(i,j) \ + BOOST_MPL_PP_ADD_DELAY(i,j) \ + /**/ + +# define BOOST_MPL_PP_ADD_DELAY(i,j) \ + BOOST_PP_CAT(BOOST_MPL_PP_TUPLE_11_ELEM_##i,BOOST_MPL_PP_ADD_##j) \ + /**/ +#else +# define BOOST_MPL_PP_ADD(i,j) \ + BOOST_MPL_PP_ADD_DELAY(i,j) \ + /**/ + +# define BOOST_MPL_PP_ADD_DELAY(i,j) \ + BOOST_MPL_PP_TUPLE_11_ELEM_##i BOOST_MPL_PP_ADD_##j \ + /**/ +#endif + +# define BOOST_MPL_PP_ADD_0 (0,1,2,3,4,5,6,7,8,9,10) +# define BOOST_MPL_PP_ADD_1 (1,2,3,4,5,6,7,8,9,10,0) +# define BOOST_MPL_PP_ADD_2 (2,3,4,5,6,7,8,9,10,0,0) +# define BOOST_MPL_PP_ADD_3 (3,4,5,6,7,8,9,10,0,0,0) +# define BOOST_MPL_PP_ADD_4 (4,5,6,7,8,9,10,0,0,0,0) +# define BOOST_MPL_PP_ADD_5 (5,6,7,8,9,10,0,0,0,0,0) +# define BOOST_MPL_PP_ADD_6 (6,7,8,9,10,0,0,0,0,0,0) +# define BOOST_MPL_PP_ADD_7 (7,8,9,10,0,0,0,0,0,0,0) +# define BOOST_MPL_PP_ADD_8 (8,9,10,0,0,0,0,0,0,0,0) +# define BOOST_MPL_PP_ADD_9 (9,10,0,0,0,0,0,0,0,0,0) +# define BOOST_MPL_PP_ADD_10 (10,0,0,0,0,0,0,0,0,0,0) + +#else + +# include + +# define BOOST_MPL_PP_ADD(i,j) \ + BOOST_PP_ADD(i,j) \ + /**/ + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_ADD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp index 26763a290b..5d72dffb87 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/default_params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/default_params.hpp new file mode 100644 index 0000000000..c904b27dd7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/default_params.hpp @@ -0,0 +1,67 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/default_params.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.5 $ + +#include + +// BOOST_MPL_PP_DEFAULT_PARAMS(0,T,int): +// BOOST_MPL_PP_DEFAULT_PARAMS(1,T,int): T1 = int +// BOOST_MPL_PP_DEFAULT_PARAMS(2,T,int): T1 = int, T2 = int +// BOOST_MPL_PP_DEFAULT_PARAMS(n,T,int): T1 = int, T2 = int, .., Tn = int + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include + +# define BOOST_MPL_PP_DEFAULT_PARAMS(n,p,v) \ + BOOST_PP_CAT(BOOST_MPL_PP_DEFAULT_PARAMS_,n)(p,v) \ + /**/ + +# define BOOST_MPL_PP_DEFAULT_PARAMS_0(p,v) +# define BOOST_MPL_PP_DEFAULT_PARAMS_1(p,v) p##1=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_2(p,v) p##1=v,p##2=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_3(p,v) p##1=v,p##2=v,p##3=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_4(p,v) p##1=v,p##2=v,p##3=v,p##4=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_5(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_6(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_7(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_8(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v,p##8=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_9(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v,p##8=v,p##9=v + +#else + +# include +# include +# include +# include +# include + +# define BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC(unused, i, pv) \ + BOOST_PP_COMMA_IF(i) \ + BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2,0,pv), BOOST_PP_INC(i) ) \ + = BOOST_PP_TUPLE_ELEM(2,1,pv) \ + /**/ + +# define BOOST_MPL_PP_DEFAULT_PARAMS(n, param, value) \ + BOOST_PP_REPEAT( \ + n \ + , BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC \ + , (param,value) \ + ) \ + /**/ + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp index 6a2a84c54c..841c03ab3d 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/enum.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/ext_params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/ext_params.hpp new file mode 100644 index 0000000000..1038eee7a8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/ext_params.hpp @@ -0,0 +1,78 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_EXT_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_EXT_PARAMS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/ext_params.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.5 $ + +#include + +// BOOST_MPL_PP_EXT_PARAMS(2,2,T): +// BOOST_MPL_PP_EXT_PARAMS(2,3,T): T2 +// BOOST_MPL_PP_EXT_PARAMS(2,4,T): T2, T3 +// BOOST_MPL_PP_EXT_PARAMS(2,n,T): T2, T3, .., Tn-1 + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include +# include + +# define BOOST_MPL_PP_EXT_PARAMS(i,j,p) \ + BOOST_MPL_PP_EXT_PARAMS_DELAY_1(i,BOOST_MPL_PP_SUB(j,i),p) \ + /**/ + +# define BOOST_MPL_PP_EXT_PARAMS_DELAY_1(i,n,p) \ + BOOST_MPL_PP_EXT_PARAMS_DELAY_2(i,n,p) \ + /**/ + +# define BOOST_MPL_PP_EXT_PARAMS_DELAY_2(i,n,p) \ + BOOST_MPL_PP_EXT_PARAMS_##i(n,p) \ + /**/ + +# define BOOST_MPL_PP_EXT_PARAMS_1(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9) +# define BOOST_MPL_PP_EXT_PARAMS_2(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9,p1) +# define BOOST_MPL_PP_EXT_PARAMS_3(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##3,p##4,p##5,p##6,p##7,p##8,p##9,p1,p2) +# define BOOST_MPL_PP_EXT_PARAMS_4(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##4,p##5,p##6,p##7,p##8,p##9,p1,p2,p3) +# define BOOST_MPL_PP_EXT_PARAMS_5(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##5,p##6,p##7,p##8,p##9,p1,p2,p3,p4) +# define BOOST_MPL_PP_EXT_PARAMS_6(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##6,p##7,p##8,p##9,p1,p2,p3,p4,p5) +# define BOOST_MPL_PP_EXT_PARAMS_7(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##7,p##8,p##9,p1,p2,p3,p4,p5,p6) +# define BOOST_MPL_PP_EXT_PARAMS_8(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##8,p##9,p1,p2,p3,p4,p5,p6,p7) +# define BOOST_MPL_PP_EXT_PARAMS_9(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##9,p1,p2,p3,p4,p5,p6,p7,p8) + +#else + +# include +# include +# include +# include +# include +# include + +# define BOOST_MPL_PP_AUX_EXT_PARAM_FUNC(unused, i, op) \ + BOOST_PP_COMMA_IF(i) \ + BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(2,1,op) \ + , BOOST_PP_ADD_D(1, i, BOOST_PP_TUPLE_ELEM(2,0,op)) \ + ) \ + /**/ + +# define BOOST_MPL_PP_EXT_PARAMS(i, j, param) \ + BOOST_PP_REPEAT( \ + BOOST_PP_SUB_D(1,j,i) \ + , BOOST_MPL_PP_AUX_EXT_PARAM_FUNC \ + , (i,param) \ + ) \ + /**/ + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_EXT_PARAMS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp index de8a58b244..b202d34f74 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/filter_params.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/is_seq.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/is_seq.hpp new file mode 100644 index 0000000000..0f7a2e790f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/is_seq.hpp @@ -0,0 +1,54 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_IS_SEQ_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_IS_SEQ_HPP_INCLUDED + +// Copyright Paul Mensonides 2003 +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/is_seq.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include + +// returns 1 if 'seq' is a PP-sequence, 0 otherwise: +// +// BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_IS_SEQ( int ) ) ) +// BOOST_PP_ASSERT( BOOST_MPL_PP_IS_SEQ( (int) ) ) +// BOOST_PP_ASSERT( BOOST_MPL_PP_IS_SEQ( (1)(2) ) ) + +#if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() + +# define BOOST_MPL_PP_IS_SEQ(seq) BOOST_PP_DEC( BOOST_PP_SEQ_SIZE( BOOST_MPL_PP_IS_SEQ_(seq) ) ) +# define BOOST_MPL_PP_IS_SEQ_(seq) BOOST_MPL_PP_IS_SEQ_SEQ_( BOOST_MPL_PP_IS_SEQ_SPLIT_ seq ) +# define BOOST_MPL_PP_IS_SEQ_SEQ_(x) (x) +# define BOOST_MPL_PP_IS_SEQ_SPLIT_(unused) unused)((unused) + +#else + +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_MPL_PP_IS_SEQ(seq) BOOST_MPL_PP_IS_SEQ_MWCC_((seq)) +# define BOOST_MPL_PP_IS_SEQ_MWCC_(args) BOOST_MPL_PP_IS_SEQ_ ## args +# else +# define BOOST_MPL_PP_IS_SEQ(seq) BOOST_MPL_PP_IS_SEQ_(seq) +# endif + +# define BOOST_MPL_PP_IS_SEQ_(seq) BOOST_PP_CAT(BOOST_MPL_PP_IS_SEQ_, BOOST_MPL_PP_IS_SEQ_0 seq BOOST_PP_RPAREN()) +# define BOOST_MPL_PP_IS_SEQ_0(x) BOOST_MPL_PP_IS_SEQ_1(x +# define BOOST_MPL_PP_IS_SEQ_ALWAYS_0(unused) 0 +# define BOOST_MPL_PP_IS_SEQ_BOOST_MPL_PP_IS_SEQ_0 BOOST_MPL_PP_IS_SEQ_ALWAYS_0( +# define BOOST_MPL_PP_IS_SEQ_BOOST_MPL_PP_IS_SEQ_1(unused) 1 + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_IS_SEQ_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp index 7cec9ffe49..9256cdc6d0 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/params.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp new file mode 100644 index 0000000000..cee22c3579 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/partial_spec_params.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include + +#define BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ +BOOST_MPL_PP_PARAMS(n, param) \ +BOOST_PP_COMMA_IF(BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,n)) \ +BOOST_MPL_PP_ENUM( \ + BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,n) \ + , def \ + ) \ +/**/ + +#endif // BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/range.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/range.hpp new file mode 100644 index 0000000000..d51eb416fc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/range.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/range.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.3 $ + +#include + +#define BOOST_MPL_PP_RANGE(first, length) \ + BOOST_PP_SEQ_SUBSEQ((0)(1)(2)(3)(4)(5)(6)(7)(8)(9), first, length) \ +/**/ + +#endif // BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/repeat.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/repeat.hpp new file mode 100644 index 0000000000..630f784179 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/repeat.hpp @@ -0,0 +1,51 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_REPEAT_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_REPEAT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/repeat.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.5 $ + +#include + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include + +# define BOOST_MPL_PP_REPEAT(n,f,param) \ + BOOST_PP_CAT(BOOST_MPL_PP_REPEAT_,n)(f,param) \ + /**/ + +# define BOOST_MPL_PP_REPEAT_0(f,p) +# define BOOST_MPL_PP_REPEAT_1(f,p) f(0,0,p) +# define BOOST_MPL_PP_REPEAT_2(f,p) f(0,0,p) f(0,1,p) +# define BOOST_MPL_PP_REPEAT_3(f,p) f(0,0,p) f(0,1,p) f(0,2,p) +# define BOOST_MPL_PP_REPEAT_4(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) +# define BOOST_MPL_PP_REPEAT_5(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) +# define BOOST_MPL_PP_REPEAT_6(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) +# define BOOST_MPL_PP_REPEAT_7(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) +# define BOOST_MPL_PP_REPEAT_8(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) f(0,7,p) +# define BOOST_MPL_PP_REPEAT_9(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) f(0,7,p) f(0,8,p) +# define BOOST_MPL_PP_REPEAT_10(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) f(0,7,p) f(0,8,p) f(0,9,p) + +#else + +# include + +# define BOOST_MPL_PP_REPEAT(n,f,param) \ + BOOST_PP_REPEAT(n,f,param) \ + /**/ + +#endif + +#define BOOST_MPL_PP_REPEAT_IDENTITY_FUNC(unused1, unused2, x) x + +#endif // BOOST_MPL_AUX_PREPROCESSOR_REPEAT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp index 93522cc3b2..f8b2e81564 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/sub.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/token_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/token_equal.hpp new file mode 100644 index 0000000000..6ec4de813f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/token_equal.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_TOKEN_EQUAL_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_TOKEN_EQUAL_HPP_INCLUDED + +// Copyright Paul Mensonides 2003 +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/token_equal.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.3 $ + +#include + +#include +#include +#include +#include +#include + +// compares tokens 'a' and 'b' for equality: +// +// #define BOOST_MPL_PP_TOKEN_EQUAL_apple(x) x +// #define BOOST_MPL_PP_TOKEN_EQUAL_orange(x) x +// +// BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_TOKEN_EQUAL(apple, abc) ) ) +// BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_TOKEN_EQUAL(abc, apple) ) ) +// BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_TOKEN_EQUAL(apple, orange) ) ) +// BOOST_PP_ASSERT( BOOST_MPL_PP_TOKEN_EQUAL(apple, apple) ) +// BOOST_PP_ASSERT( BOOST_MPL_PP_TOKEN_EQUAL(orange, orange) ) + +#define BOOST_MPL_PP_TOKEN_EQUAL(a, b) \ + BOOST_PP_IIF( \ + BOOST_PP_BITAND( \ + BOOST_MPL_PP_IS_SEQ( BOOST_PP_CAT(BOOST_MPL_PP_TOKEN_EQUAL_, a)((unused)) ) \ + , BOOST_MPL_PP_IS_SEQ( BOOST_PP_CAT(BOOST_MPL_PP_TOKEN_EQUAL_, b)((unused)) ) \ + ) \ + , BOOST_MPL_PP_TOKEN_EQUAL_I \ + , 0 BOOST_PP_TUPLE_EAT(2) \ + )(a, b) \ +/**/ + +#define BOOST_MPL_PP_TOKEN_EQUAL_I(a, b) \ + BOOST_PP_COMPL(BOOST_MPL_PP_IS_SEQ( \ + BOOST_MPL_PP_TOKEN_EQUAL_ ## a( \ + BOOST_MPL_PP_TOKEN_EQUAL_ ## b \ + )((unused)) \ + )) \ +/**/ + +#endif // BOOST_MPL_AUX_PREPROCESSOR_TOKEN_EQUAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/tuple.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/tuple.hpp new file mode 100644 index 0000000000..b2459e53bf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/tuple.hpp @@ -0,0 +1,29 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/preprocessor/tuple.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.5 $ + +#define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0 +#define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1 +#define BOOST_MPL_PP_TUPLE_11_ELEM_2(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e2 +#define BOOST_MPL_PP_TUPLE_11_ELEM_3(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e3 +#define BOOST_MPL_PP_TUPLE_11_ELEM_4(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e4 +#define BOOST_MPL_PP_TUPLE_11_ELEM_5(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e5 +#define BOOST_MPL_PP_TUPLE_11_ELEM_6(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e6 +#define BOOST_MPL_PP_TUPLE_11_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e7 +#define BOOST_MPL_PP_TUPLE_11_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e8 +#define BOOST_MPL_PP_TUPLE_11_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e9 +#define BOOST_MPL_PP_TUPLE_11_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e10 + +#endif // BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/ptr_to_ref.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/ptr_to_ref.hpp new file mode 100644 index 0000000000..49c74c9682 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/ptr_to_ref.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_AUX_PTR_TO_REF_HPP_INCLUDED +#define BOOST_MPL_AUX_PTR_TO_REF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/ptr_to_ref.hpp,v $ +// $Date: 2005/06/22 15:20:18 $ +// $Revision: 1.5 $ + +#include +#include +#include + + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || ( BOOST_WORKAROUND(__EDG_VERSION__, <= 245) \ + && !(defined(__STD_STRICT_ANSI) \ + || defined(__STD_STRICT_ANSI_ERRORS)) ) + +# define BOOST_MPL_AUX_PTR_TO_REF(X) \ + *BOOST_MPL_AUX_STATIC_CAST(X*, 0) \ +/**/ + +#else + +# define BOOST_MPL_AUX_PTR_TO_REF(X) \ + aux::ptr_to_ref(BOOST_MPL_AUX_STATIC_CAST(X*, 0)) \ +/**/ + +#endif + + +namespace boost { namespace mpl { namespace aux { + +template< typename T > static T const& ptr_to_ref(T*); + +}}} + +#endif // BOOST_MPL_AUX_PTR_TO_REF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/push_back_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/push_back_impl.hpp new file mode 100644 index 0000000000..f296e72b93 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/push_back_impl.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/push_back_impl.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// agurt 05/feb/04: no default implementation; the stub definition is needed +// to enable the default 'has_push_back' implementation below +template< typename Tag > +struct push_back_impl +{ + template< typename Sequence, typename T > struct apply {}; +}; + +template< typename Tag > +struct has_push_back_impl +{ + template< typename Seq > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : aux::has_type< push_back > + { +#else + { + typedef aux::has_type< push_back > type; + BOOST_STATIC_CONSTANT(bool, value = + (aux::has_type< push_back >::value) + ); +#endif + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, push_back_impl) +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, has_push_back_impl) + +}} + +#endif // BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/push_front_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/push_front_impl.hpp new file mode 100644 index 0000000000..6cef944258 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/push_front_impl.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/push_front_impl.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// agurt 05/feb/04: no default implementation; the stub definition is needed +// to enable the default 'has_push_front' implementation below + +template< typename Tag > +struct push_front_impl +{ + template< typename Sequence, typename T > struct apply {}; +}; + +template< typename Tag > +struct has_push_front_impl +{ + template< typename Seq > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : aux::has_type< push_front > + { +#else + { + typedef aux::has_type< push_front > type; + BOOST_STATIC_CONSTANT(bool, value = + (aux::has_type< push_front >::value) + ); +#endif + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, push_front_impl) +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, has_push_front_impl) + +}} + +#endif // BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/O1_size.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/O1_size.hpp new file mode 100644 index 0000000000..ae5545faaf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/O1_size.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/O1_size.hpp,v $ +// $Date: 2004/09/02 15:40:56 $ +// $Revision: 1.4 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct O1_size_impl< aux::half_open_range_tag > + : size_impl< aux::half_open_range_tag > +{ +}; + +}} + +#endif // BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/back.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/back.hpp new file mode 100644 index 0000000000..9f92d96158 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/back.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_BACK_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/back.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.4 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct back_impl< aux::half_open_range_tag > +{ + template< typename Range > struct apply + { + typedef typename prior< typename Range::finish >::type type; + }; +}; + +}} + +#endif // BOOST_MPL_AUX_RANGE_C_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/empty.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/empty.hpp new file mode 100644 index 0000000000..a3af984b34 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/empty.hpp @@ -0,0 +1,37 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_EMPTY_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_EMPTY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/empty.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct empty_impl< aux::half_open_range_tag > +{ + template< typename Range > struct apply + : equal_to< + typename Range::start + , typename Range::finish + > + { + }; +}; + +}} + +#endif // BOOST_MPL_AUX_RANGE_C_EMPTY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/front.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/front.hpp new file mode 100644 index 0000000000..97902b9b78 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/front.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_FRONT_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/front.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct front_impl< aux::half_open_range_tag > +{ + template< typename Range > struct apply + { + typedef typename Range::start type; + }; +}; + +}} + +#endif // BOOST_MPL_AUX_RANGE_C_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/iterator.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/iterator.hpp new file mode 100644 index 0000000000..726f602b14 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/iterator.hpp @@ -0,0 +1,106 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_ITERATOR_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_ITERATOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/iterator.hpp,v $ +// $Date: 2004/12/20 17:52:43 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// theoretically will work on any discrete numeric type +template< typename N > struct r_iter +{ + typedef aux::r_iter_tag tag; + typedef random_access_iterator_tag category; + typedef N type; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + typedef r_iter< typename mpl::next::type > next; + typedef r_iter< typename mpl::prior::type > prior; +#endif +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename N + > +struct next< r_iter > +{ + typedef r_iter< typename mpl::next::type > type; +}; + +template< + typename N + > +struct prior< r_iter > +{ + typedef r_iter< typename mpl::prior::type > type; +}; + +#endif + + +template<> struct advance_impl +{ + template< typename Iter, typename Dist > struct apply + { + typedef typename deref::type n_; +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + typedef typename plus_impl + ::template apply::type m_; +#else + typedef typename plus::type m_; +#endif + // agurt, 10/nov/04: to be generic, the code have to do something along + // the lines below... + // + // typedef typename apply_wrap1< + // numeric_cast< typename m_::tag, typename n_::tag > + // , m_ + // >::type result_; + // + // ... meanwhile: + + typedef integral_c< + typename aux::value_type_wknd::type + , BOOST_MPL_AUX_VALUE_WKND(m_)::value + > result_; + + typedef r_iter type; + }; +}; + +template<> struct distance_impl +{ + template< typename Iter1, typename Iter2 > struct apply + : minus< + typename Iter2::type + , typename Iter1::type + > + { + }; +}; + +}} + +#endif // BOOST_MPL_AUX_RANGE_C_ITERATOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/size.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/size.hpp new file mode 100644 index 0000000000..3c71f1a5fa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/size.hpp @@ -0,0 +1,37 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_SIZE_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/size.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct size_impl< aux::half_open_range_tag > +{ + template< typename Range > struct apply + : minus< + typename Range::finish + , typename Range::start + > + { + }; +}; + +}} + +#endif // BOOST_MPL_AUX_RANGE_C_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/tag.hpp new file mode 100644 index 0000000000..0951efe40f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/range_c/tag.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_AUX_RANGE_C_TAG_HPP_INCLUDED +#define BOOST_MPL_AUX_RANGE_C_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/range_c/tag.hpp,v $ +// $Date: 2004/11/28 01:31:44 $ +// $Revision: 1.5 $ + +namespace boost { namespace mpl { namespace aux { + +struct half_open_range_tag; +struct r_iter_tag; + +}}} + +#endif // BOOST_MPL_AUX_RANGE_C_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp new file mode 100644 index 0000000000..c5ea0e6f97 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/reverse_fold_impl.hpp,v $ +// $Date: 2004/10/01 16:29:34 $ +// $Revision: 1.3 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + || defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) +# include +# include +# endif +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER reverse_fold_impl.hpp +# include + +#else + +# define AUX778076_FOLD_IMPL_OP(iter) typename deref::type +# define AUX778076_FOLD_IMPL_NAME_PREFIX reverse_fold +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp new file mode 100644 index 0000000000..30a3db2a5d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp @@ -0,0 +1,412 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +#if !defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/reverse_fold_impl_body.hpp,v $ +// $Date: 2004/10/24 08:18:03 $ +// $Revision: 1.3 $ + +# include +# include +# include +# include + +# include +# include +# include +# include +# include + +// local macros, #undef-ined at the end of the header + +# define AUX778076_ITER_FOLD_FORWARD_STEP(unused, n_, unused2) \ + typedef typename apply2< \ + ForwardOp \ + , BOOST_PP_CAT(fwd_state,n_) \ + , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,n_)) \ + >::type BOOST_PP_CAT(fwd_state,BOOST_PP_INC(n_)); \ + typedef typename mpl::next::type \ + BOOST_PP_CAT(iter,BOOST_PP_INC(n_)); \ + /**/ + +# define AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC(n_) \ + typedef typename apply2< \ + BackwardOp \ + , BOOST_PP_CAT(bkwd_state,n_) \ + , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,BOOST_PP_DEC(n_))) \ + >::type BOOST_PP_CAT(bkwd_state,BOOST_PP_DEC(n_)); \ + /**/ + +# define AUX778076_ITER_FOLD_BACKWARD_STEP(unused, n_, j) \ + AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC( \ + BOOST_PP_SUB_D(1,j,n_) \ + ) \ + /**/ + +# define AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(n_) \ + typedef typename nested_chunk::state BOOST_PP_CAT(bkwd_state,n_); + /**/ + +# define AUX778076_FOLD_IMPL_NAME \ + BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \ + /**/ + +# define AUX778076_FOLD_CHUNK_NAME \ + BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \ + /**/ + +namespace boost { namespace mpl { namespace aux { + +/// forward declaration +template< + BOOST_MPL_AUX_NTTP_DECL(long, N) + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) +# include BOOST_PP_ITERATE() + +// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING +template< + BOOST_MPL_AUX_NTTP_DECL(long, N) + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME +{ + typedef First iter0; + typedef State fwd_state0; + + BOOST_MPL_PP_REPEAT( + BOOST_MPL_LIMIT_UNROLLING + , AUX778076_ITER_FOLD_FORWARD_STEP + , unused + ) + + typedef AUX778076_FOLD_IMPL_NAME< + ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) + , BOOST_PP_CAT(iter,BOOST_MPL_LIMIT_UNROLLING) + , Last + , BOOST_PP_CAT(fwd_state,BOOST_MPL_LIMIT_UNROLLING) + , BackwardOp + , ForwardOp + > nested_chunk; + + AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(BOOST_MPL_LIMIT_UNROLLING) + + BOOST_MPL_PP_REPEAT( + BOOST_MPL_LIMIT_UNROLLING + , AUX778076_ITER_FOLD_BACKWARD_STEP + , BOOST_MPL_LIMIT_UNROLLING + ) + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; +}; + +// fallback implementation for sequences of unknown size +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,BackwardOp,ForwardOp> +{ + typedef AUX778076_FOLD_IMPL_NAME< + -1 + , typename mpl::next::type + , Last + , typename apply2::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , AUX778076_FOLD_IMPL_OP(First) + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,BackwardOp,ForwardOp> +{ + typedef State state; + typedef Last iterator; +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > +struct AUX778076_FOLD_CHUNK_NAME; + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) +# include BOOST_PP_ITERATE() + +// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > +struct AUX778076_FOLD_CHUNK_NAME +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + + BOOST_MPL_PP_REPEAT( + BOOST_MPL_LIMIT_UNROLLING + , AUX778076_ITER_FOLD_FORWARD_STEP + , unused + ) + + typedef AUX778076_FOLD_IMPL_NAME< + ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) + , BOOST_PP_CAT(iter,BOOST_MPL_LIMIT_UNROLLING) + , Last + , BOOST_PP_CAT(fwd_state,BOOST_MPL_LIMIT_UNROLLING) + , BackwardOp + , ForwardOp + > nested_chunk; + + AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(BOOST_MPL_LIMIT_UNROLLING) + + BOOST_MPL_PP_REPEAT( + BOOST_MPL_LIMIT_UNROLLING + , AUX778076_ITER_FOLD_BACKWARD_STEP + , BOOST_MPL_LIMIT_UNROLLING + ) + + typedef bkwd_state0 state; + typedef typename nested_chunk::iterator iterator; + }; +}; + +// fallback implementation for sequences of unknown size +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step); + +template< + typename Last + , typename State + > +struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) +{ + typedef Last iterator; + typedef State state; +}; + +template<> +struct AUX778076_FOLD_CHUNK_NAME<-1> +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef typename if_< + typename is_same::type + , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) + , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) + >::type res_; + + typedef typename res_::state state; + typedef typename res_::iterator iterator; + }; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + /// ETI workaround + template<> struct result_ + { + typedef int state; + typedef int iterator; + }; +#endif +}; + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) +{ + typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_< + typename mpl::next::type + , Last + , typename apply2::type + , BackwardOp + , ForwardOp + > nested_step; + + typedef typename apply2< + BackwardOp + , typename nested_step::state + , AUX778076_FOLD_IMPL_OP(First) + >::type state; + + typedef typename nested_step::iterator iterator; +}; + +template< + BOOST_MPL_AUX_NTTP_DECL(long, N) + , typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME + : AUX778076_FOLD_CHUNK_NAME + ::template result_ +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +}}} + +# undef AUX778076_FIRST_BACKWARD_STATE_TYPEDEF +# undef AUX778076_ITER_FOLD_BACKWARD_STEP +# undef AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC +# undef AUX778076_ITER_FOLD_FORWARD_STEP + +#undef AUX778076_FOLD_IMPL_OP +#undef AUX778076_FOLD_IMPL_NAME_PREFIX + +///// iteration + +#else + +# define n_ BOOST_PP_FRAME_ITERATION(1) + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) + +template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > +struct AUX778076_FOLD_IMPL_NAME +{ + typedef First iter0; + typedef State fwd_state0; + + BOOST_MPL_PP_REPEAT( + n_ + , AUX778076_ITER_FOLD_FORWARD_STEP + , unused + ) + + typedef BOOST_PP_CAT(fwd_state,n_) BOOST_PP_CAT(bkwd_state,n_); + + BOOST_MPL_PP_REPEAT( + n_ + , AUX778076_ITER_FOLD_BACKWARD_STEP + , n_ + ) + + typedef bkwd_state0 state; + typedef BOOST_PP_CAT(iter,n_) iterator; +}; + +#else + +template<> struct AUX778076_FOLD_CHUNK_NAME +{ + template< + typename First + , typename Last + , typename State + , typename BackwardOp + , typename ForwardOp + > + struct result_ + { + typedef First iter0; + typedef State fwd_state0; + + BOOST_MPL_PP_REPEAT( + n_ + , AUX778076_ITER_FOLD_FORWARD_STEP + , unused + ) + + typedef BOOST_PP_CAT(fwd_state,n_) BOOST_PP_CAT(bkwd_state,n_); + + BOOST_MPL_PP_REPEAT( + n_ + , AUX778076_ITER_FOLD_BACKWARD_STEP + , n_ + ) + + typedef bkwd_state0 state; + typedef BOOST_PP_CAT(iter,n_) iterator; + }; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + /// ETI workaround + template<> struct result_ + { + typedef int state; + typedef int iterator; + }; +#endif +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +# undef n_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp new file mode 100644 index 0000000000..9c4e253305 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_AUX_ITER_FOLD_BACKWARD_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_ITER_FOLD_BACKWARD_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/reverse_iter_fold_impl.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + || defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) +# include +# include +# endif +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER reverse_iter_fold_impl.hpp +# include + +#else + +# define AUX778076_FOLD_IMPL_OP(iter) iter +# define AUX778076_FOLD_IMPL_NAME_PREFIX reverse_iter_fold +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_ITER_FOLD_BACKWARD_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/sequence_wrapper.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/sequence_wrapper.hpp new file mode 100644 index 0000000000..ebb614cec4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/sequence_wrapper.hpp @@ -0,0 +1,287 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/sequence_wrapper.hpp,v $ +// $Date: 2004/11/28 01:46:37 $ +// $Revision: 1.4 $ + +# include +# include +# include + +# include +# include +# include +# include +# include +# include +# include +# include + +#if defined(BOOST_MPL_PREPROCESSING_MODE) +# undef LONG_MAX +#endif + +namespace boost { namespace mpl { + +#if !defined(AUX778076_SEQUENCE_BASE_NAME) +# define AUX778076_SEQUENCE_BASE_NAME AUX778076_SEQUENCE_NAME +#endif + +#if !defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER) + +# define AUX778076_SEQUENCE_PARAM_NAME T +# define AUX778076_SEQUENCE_TEMPLATE_PARAM typename T +# define AUX778076_SEQUENCE_DEFAULT na + +# define AUX778076_SEQUENCE_NAME_N(n) \ + BOOST_PP_CAT(AUX778076_SEQUENCE_BASE_NAME,n) \ + /**/ + +# define AUX778076_SEQUENCE_PARAMS() \ + BOOST_PP_ENUM_PARAMS( \ + AUX778076_SEQUENCE_LIMIT \ + , AUX778076_SEQUENCE_TEMPLATE_PARAM \ + ) \ + /**/ + +# define AUX778076_SEQUENCE_ARGS() \ + BOOST_PP_ENUM_PARAMS( \ + AUX778076_SEQUENCE_LIMIT \ + , T \ + ) \ + /**/ + +# define AUX778076_SEQUENCE_DEFAULT_PARAMS() \ + BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \ + AUX778076_SEQUENCE_LIMIT \ + , AUX778076_SEQUENCE_TEMPLATE_PARAM \ + , AUX778076_SEQUENCE_DEFAULT \ + ) \ + /**/ + +# define AUX778076_SEQUENCE_N_PARAMS(n) \ + BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) \ + /**/ + +# define AUX778076_SEQUENCE_N_ARGS(n) \ + BOOST_PP_ENUM_PARAMS(n, T) \ + /**/ + +# define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) \ + BOOST_PP_ENUM_PARAMS(n, T) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_PP_ENUM( \ + BOOST_PP_SUB_D(1,AUX778076_SEQUENCE_LIMIT,n) \ + , BOOST_PP_TUPLE_ELEM_3_2 \ + , AUX778076_SEQUENCE_DEFAULT \ + ) \ + /**/ + +#else // AUX778076_SEQUENCE_INTEGRAL_WRAPPER + +# define AUX778076_SEQUENCE_PARAM_NAME C +# define AUX778076_SEQUENCE_TEMPLATE_PARAM BOOST_MPL_AUX_NTTP_DECL(long, C) +# define AUX778076_SEQUENCE_DEFAULT LONG_MAX + +# define AUX778076_SEQUENCE_PARAMS() \ + typename T, BOOST_PP_ENUM_PARAMS( \ + AUX778076_SEQUENCE_LIMIT \ + , AUX778076_SEQUENCE_TEMPLATE_PARAM \ + ) \ + /**/ + +# define AUX778076_SEQUENCE_ARGS() \ + T, BOOST_PP_ENUM_PARAMS( \ + AUX778076_SEQUENCE_LIMIT \ + , C \ + ) \ + /**/ + +# define AUX778076_SEQUENCE_DEFAULT_PARAMS() \ + typename T, \ + BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \ + AUX778076_SEQUENCE_LIMIT \ + , AUX778076_SEQUENCE_TEMPLATE_PARAM \ + , AUX778076_SEQUENCE_DEFAULT \ + ) \ + /**/ + +# define AUX778076_SEQUENCE_N_PARAMS(n) \ + typename T BOOST_PP_COMMA_IF(n) \ + BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) \ + /**/ + +# define AUX778076_SEQUENCE_N_ARGS(n) \ + T BOOST_PP_COMMA_IF(n) \ + BOOST_PP_ENUM_PARAMS(n, C) \ + /**/ + +# define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) \ + T, BOOST_PP_ENUM_PARAMS(n, C) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_PP_ENUM( \ + BOOST_PP_SUB_D(1,AUX778076_SEQUENCE_LIMIT,n) \ + , BOOST_PP_TUPLE_ELEM_3_2 \ + , AUX778076_SEQUENCE_DEFAULT \ + ) \ + /**/ + +#endif // AUX778076_SEQUENCE_INTEGRAL_WRAPPER + + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// forward declaration +template< + AUX778076_SEQUENCE_DEFAULT_PARAMS() + > +struct AUX778076_SEQUENCE_NAME; +#else +namespace aux { +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser); +} +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, AUX778076_SEQUENCE_LIMIT, )) +#include BOOST_PP_ITERATE() + +// real C++ version is already taken care of +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +namespace aux { +// ???_count_args +#define AUX778076_COUNT_ARGS_PREFIX AUX778076_SEQUENCE_NAME +#define AUX778076_COUNT_ARGS_DEFAULT AUX778076_SEQUENCE_DEFAULT +#define AUX778076_COUNT_ARGS_PARAM_NAME AUX778076_SEQUENCE_PARAM_NAME +#define AUX778076_COUNT_ARGS_TEMPLATE_PARAM AUX778076_SEQUENCE_TEMPLATE_PARAM +#define AUX778076_COUNT_ARGS_ARITY AUX778076_SEQUENCE_LIMIT +#define AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES +#include + +template< + AUX778076_SEQUENCE_PARAMS() + > +struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl) +{ + typedef aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_count_args)< + BOOST_PP_ENUM_PARAMS(AUX778076_SEQUENCE_LIMIT, AUX778076_SEQUENCE_PARAM_NAME) + > arg_num_; + + typedef typename aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser)< arg_num_::value > + ::template result_< AUX778076_SEQUENCE_ARGS() >::type type; +}; + +} // namespace aux + +template< + AUX778076_SEQUENCE_DEFAULT_PARAMS() + > +struct AUX778076_SEQUENCE_NAME + : aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)< + AUX778076_SEQUENCE_ARGS() + >::type +{ + typedef typename aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)< + AUX778076_SEQUENCE_ARGS() + >::type type; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +# undef AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS +# undef AUX778076_SEQUENCE_N_ARGS +# undef AUX778076_SEQUENCE_N_PARAMS +# undef AUX778076_SEQUENCE_DEFAULT_PARAMS +# undef AUX778076_SEQUENCE_ARGS +# undef AUX778076_SEQUENCE_PARAMS +# undef AUX778076_SEQUENCE_NAME_N +# undef AUX778076_SEQUENCE_DEFAULT +# undef AUX778076_SEQUENCE_TEMPLATE_PARAM +# undef AUX778076_SEQUENCE_PARAM_NAME +# undef AUX778076_SEQUENCE_LIMIT +# undef AUX778076_SEQUENCE_BASE_NAME +# undef AUX778076_SEQUENCE_NAME +# undef AUX778076_SEQUENCE_INTEGRAL_WRAPPER + +}} + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +#if i_ == AUX778076_SEQUENCE_LIMIT + +/// primary template (not a specialization!) +template< + AUX778076_SEQUENCE_N_PARAMS(i_) + > +struct AUX778076_SEQUENCE_NAME + : AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) > +{ + typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; +}; + +#else + +template< + AUX778076_SEQUENCE_N_PARAMS(i_) + > +struct AUX778076_SEQUENCE_NAME< AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(i_) > + : AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) > +{ +#if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER) + typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; +#else + typedef AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; +#endif +}; + +#endif // i_ == AUX778076_SEQUENCE_LIMIT + +# else + +namespace aux { + +template<> +struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser) +{ + template< + AUX778076_SEQUENCE_PARAMS() + > + struct result_ + { +#if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER) + typedef typename AUX778076_SEQUENCE_NAME_N(i_)< + AUX778076_SEQUENCE_N_ARGS(i_) + >::type type; +#else + typedef AUX778076_SEQUENCE_NAME_N(i_)< + AUX778076_SEQUENCE_N_ARGS(i_) + >::type type; +#endif + }; +}; + +} // namespace aux + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/shift_op.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/shift_op.hpp new file mode 100644 index 0000000000..de9da83d98 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/shift_op.hpp @@ -0,0 +1,87 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/shift_op.hpp,v $ +// $Date: 2004/09/07 08:51:32 $ +// $Revision: 1.4 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#if !defined(AUX778076_OP_PREFIX) +# define AUX778076_OP_PREFIX AUX778076_OP_NAME +#endif + +#define AUX778076_OP_ARITY 2 + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp +# include + +#else + +# include +# include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) +namespace aux { +template< typename T, typename Shift, T n, Shift s > +struct BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd) +{ + BOOST_STATIC_CONSTANT(T, value = (n AUX778076_OP_TOKEN s)); + typedef integral_c type; +}; +} +#endif + +template<> +struct AUX778076_OP_IMPL_NAME +{ + template< typename N, typename S > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) + : integral_c< + typename N::value_type + , ( BOOST_MPL_AUX_VALUE_WKND(N)::value + AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(S)::value + ) + > +#else + : aux::BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)< + typename N::value_type + , typename S::value_type + , N::value + , S::value + >::type +#endif + { + }; +}; + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#undef AUX778076_OP_TAG_NAME +#undef AUX778076_OP_IMPL_NAME +#undef AUX778076_OP_ARITY +#undef AUX778076_OP_PREFIX +#undef AUX778076_OP_NAME +#undef AUX778076_OP_TOKEN diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/single_element_iter.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/single_element_iter.hpp new file mode 100644 index 0000000000..410f2f802c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/single_element_iter.hpp @@ -0,0 +1,118 @@ + +#ifndef BOOST_MPL_AUX_SINGLE_ELEMENT_ITER_HPP_INCLUDED +#define BOOST_MPL_AUX_SINGLE_ELEMENT_ITER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/single_element_iter.hpp,v $ +// $Date: 2004/11/28 01:47:44 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +namespace aux { + +template< typename T, BOOST_MPL_AUX_NTTP_DECL(int, is_last_) > +struct sel_iter; + +template< typename T > +struct sel_iter +{ + typedef random_access_iterator_tag category; + typedef sel_iter next; + typedef T type; +}; + +template< typename T > +struct sel_iter +{ + typedef random_access_iterator_tag category; + typedef sel_iter prior; +}; + +} // namespace aux + +template< typename T, BOOST_MPL_AUX_NTTP_DECL(int, is_last_), typename Distance > +struct advance< aux::sel_iter,Distance> +{ + typedef aux::sel_iter< + T + , ( is_last_ + BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Distance) ) + > type; +}; + +template< + typename T + , BOOST_MPL_AUX_NTTP_DECL(int, l1) + , BOOST_MPL_AUX_NTTP_DECL(int, l2) + > +struct distance< aux::sel_iter, aux::sel_iter > + : int_<( l2 - l1 )> +{ +}; + +#else + +namespace aux { + +struct sel_iter_tag; + +template< typename T, BOOST_MPL_AUX_NTTP_DECL(int, is_last_) > +struct sel_iter +{ + enum { pos_ = is_last_ }; + typedef aux::sel_iter_tag tag; + typedef random_access_iterator_tag category; + + typedef sel_iter next; + typedef sel_iter prior; + typedef T type; +}; + +} // namespace aux + +template<> struct advance_impl +{ + template< typename Iterator, typename N > struct apply + { + enum { pos_ = Iterator::pos_, n_ = N::value }; + typedef aux::sel_iter< + typename Iterator::type + , (pos_ + n_) + > type; + }; +}; + +template<> struct distance_impl +{ + template< typename Iter1, typename Iter2 > struct apply + { + enum { pos1_ = Iter1::pos_, pos2_ = Iter2::pos_ }; + typedef int_<( pos2_ - pos1_ )> type; + BOOST_STATIC_CONSTANT(int, value = ( pos2_ - pos1_ )); + }; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +}} + +#endif // BOOST_MPL_AUX_SINGLE_ELEMENT_ITER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/size_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/size_impl.hpp new file mode 100644 index 0000000000..d10ca8e603 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/size_impl.hpp @@ -0,0 +1,52 @@ + +#ifndef BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/size_impl.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// default implementation; conrete sequences might override it by +// specializing either the 'size_impl' or the primary 'size' template + +template< typename Tag > +struct size_impl +{ + template< typename Sequence > struct apply +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) + : distance< + typename begin::type + , typename end::type + > + { +#else + { + typedef typename distance< + typename begin::type + , typename end::type + >::type type; +#endif + }; +}; + +BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, size_impl) + +}} + +#endif // BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/sort_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/sort_impl.hpp new file mode 100644 index 0000000000..b1e3b49424 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/sort_impl.hpp @@ -0,0 +1,121 @@ + +#ifndef BOOST_MPL_AUX_SORT_IMPL_HPP_INCLUDED +#define BOOST_MPL_AUX_SORT_IMPL_HPP_INCLUDED + +// 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/sort_impl.hpp,v $ +// $Date: 2004/11/28 01:47:44 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename Seq, typename Pred > +struct quick_sort; + +// agurt, 10/nov/04: for the sake of deficeint compilers +template< typename Pred, typename Pivot > +struct quick_sort_pred +{ + template< typename T > struct apply + { + typedef typename apply2::type type; + }; +}; + +template< + typename Seq + , typename Pred + > +struct quick_sort_impl +{ + typedef typename begin::type pivot; + typedef typename partition< + iterator_range< + typename next::type + , typename end::type + > + , protect< aux::quick_sort_pred< Pred, typename deref::type > > + , back_inserter< vector<> > + , back_inserter< vector<> > + >::type partitioned; + + typedef typename quick_sort< typename partitioned::first, Pred >::type part1; + typedef typename quick_sort< typename partitioned::second, Pred >::type part2; + + typedef joint_view< + joint_view< part1, single_view< typename deref::type > > + , part2 + > type; +}; + +template< + typename Seq + , typename Pred + > +struct quick_sort + : eval_if< + empty + , identity + , quick_sort_impl + > +{ +}; + + +template < + typename Sequence + , typename Pred + , typename In + > +struct sort_impl +{ + typedef typename quick_sort< + Sequence + , typename if_na >::type + >::type result_; + + typedef typename copy::type type; +}; + +template < + typename Sequence + , typename Pred + , typename In + > +struct reverse_sort_impl +{ + typedef typename quick_sort< + Sequence + , typename if_na >::type + >::type result_; + + typedef typename reverse_copy::type type; +}; + +}}} + +#endif // BOOST_MPL_AUX_SORT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/static_cast.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/static_cast.hpp index 1ccaf303b6..65fe0e223b 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/static_cast.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/static_cast.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/static_cast.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity.hpp new file mode 100644 index 0000000000..cbabbe1e05 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity.hpp @@ -0,0 +1,189 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED +#define BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/template_arity.hpp,v $ +// $Date: 2004/09/07 12:24:48 $ +// $Revision: 1.11 $ + +#include +#include + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# include +# endif +# else +# include +# endif +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER template_arity.hpp +# include + +#else + +# if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) + +# include +# include +# include +# include +# include + +# include +# include +# include +# include +# include + +# define AUX778076_ARITY BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) + +namespace boost { namespace mpl { namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arity_tag +{ + typedef char (&type)[N + 1]; +}; + +# define AUX778076_MAX_ARITY_OP(unused, state, i_) \ + ( BOOST_PP_CAT(C,i_) > 0 ? BOOST_PP_CAT(C,i_) : state ) \ +/**/ + +template< + BOOST_MPL_PP_PARAMS(AUX778076_ARITY, BOOST_MPL_AUX_NTTP_DECL(int, C)) + > +struct max_arity +{ + BOOST_STATIC_CONSTANT(int, value = + BOOST_PP_SEQ_FOLD_LEFT( + AUX778076_MAX_ARITY_OP + , -1 + , BOOST_MPL_PP_RANGE(1, AUX778076_ARITY) + ) + ); +}; + +# undef AUX778076_MAX_ARITY_OP + +arity_tag<0>::type arity_helper(...); + +# define BOOST_PP_ITERATION_LIMITS (1, AUX778076_ARITY) +# define BOOST_PP_FILENAME_1 +# include BOOST_PP_ITERATE() + +template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct template_arity_impl +{ + BOOST_STATIC_CONSTANT(int, value = + sizeof(arity_helper(type_wrapper(),arity_tag())) - 1 + ); +}; + +# define AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION(unused, i_, F) \ + BOOST_PP_COMMA_IF(i_) template_arity_impl::value \ +/**/ + +template< typename F > +struct template_arity +{ + BOOST_STATIC_CONSTANT(int, value = ( + max_arity< BOOST_MPL_PP_REPEAT( + AUX778076_ARITY + , AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION + , F + ) >::value + )); + + typedef mpl::int_ type; +}; + +# undef AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION + +# undef AUX778076_ARITY + +}}} + +# endif // BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +# else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +# include + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_<-1> + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +template<> +struct template_arity + : mpl::int_<-1> +{ +}; +#endif + +}}} + +# endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + template< BOOST_MPL_PP_PARAMS(i_, typename P) > class F + , BOOST_MPL_PP_PARAMS(i_, typename T) + > +typename arity_tag::type +arity_helper(type_wrapper< F >, arity_tag); + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp index 087010d237..2ae372aa1e 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/template_arity_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/test.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/test.hpp new file mode 100644 index 0000000000..0b0c875b88 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/test.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_AUX_TEST_HPP_INCLUDED +#define BOOST_MPL_AUX_TEST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/test.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.3 $ + +#include +#include +#include + +#include + +int main() +{ + return 0; +} + +using namespace boost; +using namespace mpl; + +#endif // BOOST_MPL_AUX_TEST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/test/assert.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/test/assert.hpp new file mode 100644 index 0000000000..ab37bd4b81 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/test/assert.hpp @@ -0,0 +1,29 @@ + +#ifndef BOOST_MPL_AUX_TEST_ASSERT_HPP_INCLUDED +#define BOOST_MPL_AUX_TEST_ASSERT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/test/assert.hpp,v $ +// $Date: 2004/10/01 16:29:37 $ +// $Revision: 1.4 $ + +#include +#include + +#define MPL_ASSERT(pred) BOOST_MPL_ASSERT(pred) +#define MPL_ASSERT_NOT(pred) BOOST_MPL_ASSERT_NOT(pred) +#define MPL_ASSERT_MSG(c, msg, types) BOOST_MPL_ASSERT_MSG(c, msg, types) +#define MPL_ASSERT_RELATION(x, rel, y) BOOST_MPL_ASSERT_RELATION(x, rel, y) + +#define MPL_ASSERT_INSTANTIATION(x) \ + enum { BOOST_PP_CAT(instantiation_test, __LINE__) = sizeof( x ) } \ +/**/ + +#endif // BOOST_MPL_AUX_TEST_ASSERT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/test/data.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/test/data.hpp new file mode 100644 index 0000000000..59799051c7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/test/data.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_AUX_TEST_DATA_HPP_INCLUDED +#define BOOST_MPL_AUX_TEST_DATA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/test/data.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.3 $ + +#include + +enum enum_ {}; +struct UDT {}; +struct incomplete; +class abstract { public: virtual ~abstract() = 0; }; +using boost::noncopyable; + +#endif // BOOST_MPL_AUX_TEST_DATA_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/test/test_case.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/test/test_case.hpp new file mode 100644 index 0000000000..d946359d9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/test/test_case.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_AUX_TEST_TEST_CASE_HPP_INCLUDED +#define BOOST_MPL_AUX_TEST_TEST_CASE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/test/test_case.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.3 $ + +#include + +#define MPL_TEST_CASE() void BOOST_PP_CAT(test,__LINE__)() + +#endif // BOOST_MPL_AUX_TEST_TEST_CASE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/traits_lambda_spec.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/traits_lambda_spec.hpp new file mode 100644 index 0000000000..6c9d47b2de --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/traits_lambda_spec.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED +#define BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/traits_lambda_spec.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.6 $ + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) + +# define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait) /**/ + +#elif !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) + +# define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait) \ +template<> struct trait \ +{ \ + template< BOOST_MPL_PP_PARAMS(i, typename T) > struct apply \ + { \ + }; \ +}; \ +/**/ + +#else + +# define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait) \ +template<> struct trait \ +{ \ + template< BOOST_MPL_PP_PARAMS(i, typename T) > struct apply \ + { \ + }; \ +}; \ +template<> struct trait \ +{ \ + template< BOOST_MPL_PP_PARAMS(i, typename T) > struct apply \ + { \ + typedef int type; \ + }; \ +}; \ +/**/ + +#endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +#endif // BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/transform_iter.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/transform_iter.hpp new file mode 100644 index 0000000000..d35436065d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/transform_iter.hpp @@ -0,0 +1,123 @@ + +#ifndef BOOST_MPL_AUX_TRANSFORM_ITER_HPP_INCLUDED +#define BOOST_MPL_AUX_TRANSFORM_ITER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/transform_iter.hpp,v $ +// $Date: 2004/09/07 12:07:56 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename Iterator + , typename LastIterator + , typename F + > +struct transform_iter +{ + typedef Iterator base; + typedef forward_iterator_tag category; + typedef transform_iter< typename mpl::next::type,LastIterator,F > next; + + typedef typename apply1< + F + , typename deref::type + >::type type; +}; + +template< + typename LastIterator + , typename F + > +struct transform_iter< LastIterator,LastIterator,F > +{ + typedef LastIterator base; + typedef forward_iterator_tag category; +}; + +#else + +template< + typename Iterator + , typename LastIterator + , typename F + > +struct transform_iter; + +template< bool > +struct transform_iter_impl +{ + template< + typename Iterator + , typename LastIterator + , typename F + > + struct result_ + { + typedef Iterator base; + typedef forward_iterator_tag category; + typedef transform_iter< typename mpl::next::type,LastIterator,F > next; + + typedef typename apply1< + F + , typename deref::type + >::type type; + }; +}; + +template<> +struct transform_iter_impl +{ + template< + typename Iterator + , typename LastIterator + , typename F + > + struct result_ + { + typedef Iterator base; + typedef forward_iterator_tag category; + }; +}; + +template< + typename Iterator + , typename LastIterator + , typename F + > +struct transform_iter + : transform_iter_impl< + ::boost::is_same::value + >::template result_< Iterator,LastIterator,F > +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace aux + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::transform_iter) + +}} + +#endif // BOOST_MPL_AUX_TRANSFORM_ITER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/type_wrapper.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/type_wrapper.hpp new file mode 100644 index 0000000000..a92d0a3ab8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/type_wrapper.hpp @@ -0,0 +1,47 @@ + +#ifndef BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED +#define BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Peter Dimov 2000-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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/type_wrapper.hpp,v $ +// $Date: 2004/09/28 13:56:59 $ +// $Revision: 1.6 $ + +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename T > struct type_wrapper +{ + typedef T type; +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// agurt 08/may/03: a complicated way to extract the wrapped type; need it +// mostly for the sake of GCC (3.2.x), which ICEs if you try to extract the +// nested 'type' from 'type_wrapper' when the latter was the result of a +// 'typeof' expression +template< typename T > struct wrapped_type; + +template< typename T > struct wrapped_type< type_wrapper > +{ + typedef T type; +}; +#else +template< typename W > struct wrapped_type +{ + typedef typename W::type type; +}; +#endif + +}}} + +#endif // BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/unwrap.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/unwrap.hpp new file mode 100644 index 0000000000..f8b1ee1364 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/unwrap.hpp @@ -0,0 +1,47 @@ + +#ifndef BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED +#define BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED + +// Copyright Peter Dimov and Multi Media Ltd 2001, 2002 +// Copyright David Abrahams 2001 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/unwrap.hpp,v $ +// $Date: 2004/09/02 15:40:44 $ +// $Revision: 1.3 $ + +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename F > +inline +F& unwrap(F& f, long) +{ + return f; +} + +template< typename F > +inline +F& +unwrap(reference_wrapper& f, int) +{ + return f; +} + +template< typename F > +inline +F& +unwrap(reference_wrapper const& f, int) +{ + return f; +} + +}}} + +#endif // BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp index 90aecec046..9bd5897849 100644 --- a/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/value_wknd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/yes_no.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/yes_no.hpp new file mode 100644 index 0000000000..c2c1e6aebf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/yes_no.hpp @@ -0,0 +1,58 @@ + +#ifndef BOOST_MPL_AUX_YES_NO_HPP_INCLUDED +#define BOOST_MPL_AUX_YES_NO_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/aux_/yes_no.hpp,v $ +// $Date: 2004/09/28 13:56:59 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include + + +namespace boost { namespace mpl { namespace aux { + +typedef char (&no_tag)[1]; +typedef char (&yes_tag)[2]; + +template< bool C_ > struct yes_no_tag +{ + typedef no_tag type; +}; + +template<> struct yes_no_tag +{ + typedef yes_tag type; +}; + + +template< BOOST_MPL_AUX_NTTP_DECL(long, n) > struct weighted_tag +{ +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1200) + typedef char (&type)[n]; +#else + char buf[n]; + typedef weighted_tag type; +#endif +}; + +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) +template<> struct weighted_tag<0> +{ + typedef char (&type)[1]; +}; +#endif + +}}} + +#endif // BOOST_MPL_AUX_YES_NO_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/back.hpp b/deal.II/contrib/boost/include/boost/mpl/back.hpp new file mode 100644 index 0000000000..b140d06b1f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/back.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_BACK_HPP_INCLUDED +#define BOOST_MPL_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/back.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct back + : back_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,back,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, back) + +}} + +#endif // BOOST_MPL_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/back_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/back_fwd.hpp new file mode 100644 index 0000000000..c4892591bd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/back_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_BACK_FWD_HPP_INCLUDED +#define BOOST_MPL_BACK_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/back_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct back_impl; +template< typename Sequence > struct back; + +}} + +#endif // BOOST_MPL_BACK_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/back_inserter.hpp b/deal.II/contrib/boost/include/boost/mpl/back_inserter.hpp new file mode 100644 index 0000000000..614231e82b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/back_inserter.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_BACK_INSERTER_HPP_INCLUDED +#define BOOST_MPL_BACK_INSERTER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/back_inserter.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { +namespace mpl { + +template< + typename Sequence + > +struct back_inserter + : inserter< Sequence,push_back<> > +{ +}; + +}} + +#endif // BOOST_MPL_BACK_INSERTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/base.hpp b/deal.II/contrib/boost/include/boost/mpl/base.hpp new file mode 100644 index 0000000000..8bc5a57575 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/base.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_BASE_HPP_INCLUDED +#define BOOST_MPL_BASE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/base.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct base +{ + typedef typename T::base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,base,(T)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, base) + +}} + +#endif // BOOST_MPL_BASE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/begin.hpp b/deal.II/contrib/boost/include/boost/mpl/begin.hpp new file mode 100644 index 0000000000..58378a69b6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/begin.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_BEGIN_HPP_INCLUDED +#define BOOST_MPL_BEGIN_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/begin.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include + +#endif // BOOST_MPL_BEGIN_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/begin_end.hpp b/deal.II/contrib/boost/include/boost/mpl/begin_end.hpp new file mode 100644 index 0000000000..d535501f6a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/begin_end.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_BEGIN_END_HPP_INCLUDED +#define BOOST_MPL_BEGIN_END_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/begin_end.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// agurt, 13/sep/02: switched from inheritance to typedef; MSVC is more +// happy this way (less ETI-related errors), and it doesn't affect +// anything else +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct begin +{ + typedef typename sequence_tag::type tag_; + typedef typename begin_impl< tag_ > + ::template apply< Sequence >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,begin,(Sequence)) +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct end +{ + typedef typename sequence_tag::type tag_; + typedef typename end_impl< tag_ > + ::template apply< Sequence >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,end,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, begin) +BOOST_MPL_AUX_NA_SPEC(1, end) + +}} + +#endif // BOOST_MPL_BEGIN_END_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/begin_end_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/begin_end_fwd.hpp new file mode 100644 index 0000000000..a8280f3fa4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/begin_end_fwd.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED +#define BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/begin_end_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct begin_impl; +template< typename Tag > struct end_impl; + +template< typename Sequence > struct begin; +template< typename Sequence > struct end; + +}} + +#endif // BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bind.hpp b/deal.II/contrib/boost/include/boost/mpl/bind.hpp new file mode 100644 index 0000000000..869eb956a4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bind.hpp @@ -0,0 +1,547 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_BIND_HPP_INCLUDED +#define BOOST_MPL_BIND_HPP_INCLUDED + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/bind.hpp,v $ +// $Date: 2004/10/26 14:51:04 $ +// $Revision: 1.13 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# include +# endif +#endif + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# if defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) +# define BOOST_MPL_PREPROCESSED_HEADER basic_bind.hpp +# else +# define BOOST_MPL_PREPROCESSED_HEADER bind.hpp +# endif +# include + +#else + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_APPLY \ + BOOST_PP_CAT(apply_wrap,BOOST_MPL_LIMIT_METAFUNCTION_ARITY) \ + /**/ + +# if defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) +# define AUX778076_DMC_PARAM() , int dummy_ +# else +# define AUX778076_DMC_PARAM() +# endif + +# define AUX778076_BIND_PARAMS(param) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ + +# define AUX778076_BIND_DEFAULT_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ + +# define AUX778076_BIND_N_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_BIND_N_SPEC_PARAMS(n, param, def) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ + /**/ + +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define AUX778076_BIND_NESTED_DEFAULT_PARAMS(param, value) \ + AUX778076_BIND_DEFAULT_PARAMS(param, value) \ + /**/ +#else +# define AUX778076_BIND_NESTED_DEFAULT_PARAMS(param, value) \ + AUX778076_BIND_PARAMS(param) \ + /**/ +#endif + +namespace aux { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename T, AUX778076_BIND_PARAMS(typename U) + > +struct resolve_bind_arg +{ + typedef T type; +}; + +# if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) + +template< + typename T + , typename Arg + > +struct replace_unnamed_arg +{ + typedef Arg next; + typedef T type; +}; + +template< + typename Arg + > +struct replace_unnamed_arg< arg<-1>,Arg > +{ + typedef typename Arg::next next; + typedef Arg type; +}; + +# endif // BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT + +template< + BOOST_MPL_AUX_NTTP_DECL(int, N), AUX778076_BIND_PARAMS(typename U) + > +struct resolve_bind_arg< arg,AUX778076_BIND_PARAMS(U) > +{ + typedef typename AUX778076_APPLY, AUX778076_BIND_PARAMS(U)>::type type; +}; + +#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) +template< + typename F, AUX778076_BIND_PARAMS(typename T), AUX778076_BIND_PARAMS(typename U) + > +struct resolve_bind_arg< bind,AUX778076_BIND_PARAMS(U) > +{ + typedef bind f_; + typedef typename AUX778076_APPLY::type type; +}; +#endif + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// agurt, 15/jan/02: it's not a intended to be used as a function class, and +// MSVC6.5 has problems with 'apply' name here (the code compiles, but doesn't +// work), so I went with the 'result_' here, and in all other similar cases +template< bool > +struct resolve_arg_impl +{ + template< typename T, AUX778076_BIND_PARAMS(typename U) > struct result_ + { + typedef T type; + }; +}; + +template<> +struct resolve_arg_impl +{ + template< typename T, AUX778076_BIND_PARAMS(typename U) > struct result_ + { + typedef typename AUX778076_APPLY< + T + , AUX778076_BIND_PARAMS(U) + >::type type; + }; +}; + +// for 'resolve_bind_arg' +template< typename T > struct is_bind_template; + +template< + typename T, AUX778076_BIND_PARAMS(typename U) + > +struct resolve_bind_arg + : resolve_arg_impl< is_bind_template::value > + ::template result_< T,AUX778076_BIND_PARAMS(U) > +{ +}; + +# if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) + +template< typename T > +struct replace_unnamed_arg_impl +{ + template< typename Arg > struct result_ + { + typedef Arg next; + typedef T type; + }; +}; + +template<> +struct replace_unnamed_arg_impl< arg<-1> > +{ + template< typename Arg > struct result_ + { + typedef typename next::type next; + typedef Arg type; + }; +}; + +template< typename T, typename Arg > +struct replace_unnamed_arg + : replace_unnamed_arg_impl::template result_ +{ +}; + +# endif // BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT + +// agurt, 10/mar/02: the forward declaration has to appear before any of +// 'is_bind_helper' overloads, otherwise MSVC6.5 issues an ICE on it +template< BOOST_MPL_AUX_NTTP_DECL(int, arity_) > struct bind_chooser; + +aux::no_tag is_bind_helper(...); +template< typename T > aux::no_tag is_bind_helper(protect*); + +// overload for "main" form +// agurt, 15/mar/02: MSVC 6.5 fails to properly resolve the overload +// in case if we use 'aux::type_wrapper< bind<...> >' here, and all +// 'bind' instantiations form a complete type anyway +#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) +template< + typename F, AUX778076_BIND_PARAMS(typename T) + > +aux::yes_tag is_bind_helper(bind*); +#endif + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > +aux::yes_tag is_bind_helper(arg*); + +template< bool is_ref_ = true > +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template<> +struct is_bind_template_impl +{ + template< typename T > struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_bind_helper(static_cast(0))) + == sizeof(aux::yes_tag) + ); + }; +}; + +template< typename T > struct is_bind_template + : is_bind_template_impl< ::boost::detail::is_reference_impl::value > + ::template result_ +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace aux + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) +/// if_/eval_if specializations +# define AUX778076_SPEC_NAME if_ +# define BOOST_PP_ITERATION_PARAMS_1 (3,(3, 3, )) +# include BOOST_PP_ITERATE() + +#if !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) +# define AUX778076_SPEC_NAME eval_if +# define BOOST_PP_ITERATION_PARAMS_1 (3,(3, 3, )) +# include BOOST_PP_ITERATE() +#endif +#endif + +// real C++ version is already taken care of +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) + +namespace aux { +// apply_count_args +#define AUX778076_COUNT_ARGS_PREFIX bind +#define AUX778076_COUNT_ARGS_DEFAULT na +#define AUX778076_COUNT_ARGS_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY +#include +} + +// bind +template< + typename F, AUX778076_BIND_PARAMS(typename T) AUX778076_DMC_PARAM() + > +struct bind + : aux::bind_chooser< + aux::bind_count_args::value + >::template result_< F,AUX778076_BIND_PARAMS(T) >::type +{ +}; + +BOOST_MPL_AUX_ARITY_SPEC( + BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) + , bind + ) + +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC( + BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) + , bind + ) + + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +# undef AUX778076_BIND_NESTED_DEFAULT_PARAMS +# undef AUX778076_BIND_N_SPEC_PARAMS +# undef AUX778076_BIND_N_PARAMS +# undef AUX778076_BIND_DEFAULT_PARAMS +# undef AUX778076_BIND_PARAMS +# undef AUX778076_DMC_PARAM +# undef AUX778076_APPLY + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_BIND_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +#if defined(AUX778076_SPEC_NAME) + +// lazy metafunction specialization +template< template< BOOST_MPL_PP_PARAMS(i_, typename T) > class F, typename Tag > +struct BOOST_PP_CAT(quote,i_); + +template< BOOST_MPL_PP_PARAMS(i_, typename T) > struct AUX778076_SPEC_NAME; + +template< + typename Tag AUX778076_BIND_N_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(bind,i_)< + BOOST_PP_CAT(quote,i_) + AUX778076_BIND_N_PARAMS(i_,T) + > +{ + template< + AUX778076_BIND_NESTED_DEFAULT_PARAMS(typename U, na) + > + struct apply + { + private: + typedef mpl::arg<1> n1; +# define BOOST_PP_ITERATION_PARAMS_2 (3,(1, i_, )) +# include BOOST_PP_ITERATE() + + typedef typename AUX778076_SPEC_NAME< + typename t1::type + , BOOST_MPL_PP_EXT_PARAMS(2, BOOST_PP_INC(i_), t) + >::type f_; + + public: + typedef typename f_::type type; + }; +}; + +#undef AUX778076_SPEC_NAME + +#else // AUX778076_SPEC_NAME + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) AUX778076_DMC_PARAM() + > +struct BOOST_PP_CAT(bind,i_) +{ + template< + AUX778076_BIND_NESTED_DEFAULT_PARAMS(typename U, na) + > + struct apply + { + private: +# if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) + + typedef aux::replace_unnamed_arg< F,mpl::arg<1> > r0; + typedef typename r0::type a0; + typedef typename r0::next n1; + typedef typename aux::resolve_bind_arg::type f_; + /// +# else + typedef typename aux::resolve_bind_arg::type f_; + +# endif // BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT + +# if i_ > 0 +# define BOOST_PP_ITERATION_PARAMS_2 (3,(1, i_, )) +# include BOOST_PP_ITERATE() +# endif + + public: + +# define AUX778076_ARG(unused, i_, t) \ + BOOST_PP_COMMA_IF(i_) \ + typename BOOST_PP_CAT(t,BOOST_PP_INC(i_))::type \ +/**/ + + typedef typename BOOST_PP_CAT(apply_wrap,i_)< + f_ + BOOST_PP_COMMA_IF(i_) BOOST_MPL_PP_REPEAT(i_, AUX778076_ARG, t) + >::type type; + +# undef AUX778076_ARG + }; +}; + +namespace aux { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T), AUX778076_BIND_PARAMS(typename U) + > +struct resolve_bind_arg< + BOOST_PP_CAT(bind,i_),AUX778076_BIND_PARAMS(U) + > +{ + typedef BOOST_PP_CAT(bind,i_) f_; + typedef typename AUX778076_APPLY::type type; +}; + +#else + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) + > +aux::yes_tag +is_bind_helper(BOOST_PP_CAT(bind,i_)*); + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace aux + +BOOST_MPL_AUX_ARITY_SPEC(BOOST_PP_INC(i_), BOOST_PP_CAT(bind,i_)) +BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(BOOST_PP_INC(i_), BOOST_PP_CAT(bind,i_)) + +# if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +#if i_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY +/// primary template (not a specialization!) +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) AUX778076_DMC_PARAM() + > +struct bind + : BOOST_PP_CAT(bind,i_) +{ +}; +#else +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) AUX778076_DMC_PARAM() + > +struct bind< F AUX778076_BIND_N_SPEC_PARAMS(i_, T, na) > + : BOOST_PP_CAT(bind,i_) +{ +}; +#endif + +# else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace aux { + +template<> +struct bind_chooser +{ + template< + typename F, AUX778076_BIND_PARAMS(typename T) + > + struct result_ + { + typedef BOOST_PP_CAT(bind,i_)< F AUX778076_BIND_N_PARAMS(i_,T) > type; + }; +}; + +} // namespace aux + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# endif // BOOST_MPL_CFG_NO_BIND_TEMPLATE + +#endif // AUX778076_SPEC_NAME + +# undef i_ + +///// iteration, depth == 2 + +#elif BOOST_PP_ITERATION_DEPTH() == 2 + +# define j_ BOOST_PP_FRAME_ITERATION(2) +# if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) + + typedef aux::replace_unnamed_arg< BOOST_PP_CAT(T,j_),BOOST_PP_CAT(n,j_) > BOOST_PP_CAT(r,j_); + typedef typename BOOST_PP_CAT(r,j_)::type BOOST_PP_CAT(a,j_); + typedef typename BOOST_PP_CAT(r,j_)::next BOOST_PP_CAT(n,BOOST_PP_INC(j_)); + typedef aux::resolve_bind_arg BOOST_PP_CAT(t,j_); + /// +# else + typedef aux::resolve_bind_arg< BOOST_PP_CAT(T,j_),AUX778076_BIND_PARAMS(U)> BOOST_PP_CAT(t,j_); + +# endif +# undef j_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/bind_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/bind_fwd.hpp new file mode 100644 index 0000000000..dc2024bf19 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bind_fwd.hpp @@ -0,0 +1,99 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_BIND_FWD_HPP_INCLUDED +#define BOOST_MPL_BIND_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/bind_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER bind_fwd.hpp +# include + +#else + +# include +# include +# include +# include + +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header + +# if defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) +# define AUX778076_DMC_PARAM() , int dummy_ = 0 +# else +# define AUX778076_DMC_PARAM() +# endif + +# define AUX778076_BIND_DEFAULT_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + AUX778076_DMC_PARAM() \ + /**/ + +# define AUX778076_BIND_N_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) BOOST_MPL_PP_PARAMS(n, param) \ + AUX778076_DMC_PARAM() \ + /**/ + +#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) +template< + typename F, AUX778076_BIND_DEFAULT_PARAMS(typename T, na) + > +struct bind; +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +# undef AUX778076_BIND_N_PARAMS +# undef AUX778076_BIND_DEFAULT_PARAMS +# undef AUX778076_DMC_PARAM +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_BIND_FWD_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(bind,i_); + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/bitand.hpp b/deal.II/contrib/boost/include/boost/mpl/bitand.hpp new file mode 100644 index 0000000000..50c82bf488 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bitand.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_BITAND_HPP_INCLUDED +#define BOOST_MPL_BITAND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/bitand.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME bitand_ +#define AUX778076_OP_PREFIX bitand +#define AUX778076_OP_TOKEN & +#include + +#endif // BOOST_MPL_BITAND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bitor.hpp b/deal.II/contrib/boost/include/boost/mpl/bitor.hpp new file mode 100644 index 0000000000..e17f4a0ddd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bitor.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_BITOR_HPP_INCLUDED +#define BOOST_MPL_BITOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/bitor.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME bitor_ +#define AUX778076_OP_PREFIX bitor +#define AUX778076_OP_TOKEN | +#include + +#endif // BOOST_MPL_BITOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bitwise.hpp b/deal.II/contrib/boost/include/boost/mpl/bitwise.hpp new file mode 100644 index 0000000000..abbf0dd960 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bitwise.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_BITWISE_HPP_INCLUDED +#define BOOST_MPL_BITWISE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright Jaap Suter 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/bitwise.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include + +#endif // BOOST_MPL_BITWISE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bitxor.hpp b/deal.II/contrib/boost/include/boost/mpl/bitxor.hpp new file mode 100644 index 0000000000..203b3a3c99 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bitxor.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_BITXOR_HPP_INCLUDED +#define BOOST_MPL_BITXOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/bitxor.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME bitxor_ +#define AUX778076_OP_PREFIX bitxor +#define AUX778076_OP_TOKEN ^ +#include + +#endif // BOOST_MPL_BITXOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bool.hpp b/deal.II/contrib/boost/include/boost/mpl/bool.hpp index 6270be739b..ce7b3d47ea 100644 --- a/deal.II/contrib/boost/include/boost/mpl/bool.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/bool.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/bool.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp index 618534e953..99533f7c64 100644 --- a/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/bool_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/clear.hpp b/deal.II/contrib/boost/include/boost/mpl/clear.hpp new file mode 100644 index 0000000000..0850514a16 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/clear.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_CLEAR_HPP_INCLUDED +#define BOOST_MPL_CLEAR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/clear.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct clear + : clear_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,clear,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, clear) + +}} + +#endif // BOOST_MPL_CLEAR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/clear_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/clear_fwd.hpp new file mode 100644 index 0000000000..22ea994df5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/clear_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_CLEAR_FWD_HPP_INCLUDED +#define BOOST_MPL_CLEAR_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/clear_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct clear_impl; +template< typename Sequence > struct clear; + +}} + +#endif // BOOST_MPL_CLEAR_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/comparison.hpp b/deal.II/contrib/boost/include/boost/mpl/comparison.hpp new file mode 100644 index 0000000000..2c4d72bfbe --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/comparison.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_COMPARISON_HPP_INCLUDED +#define BOOST_MPL_COMPARISON_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/comparison.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include + +#endif // BOOST_MPL_COMPARISON_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/contains.hpp b/deal.II/contrib/boost/include/boost/mpl/contains.hpp new file mode 100644 index 0000000000..ed14ebedf5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/contains.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_CONTAINS_HPP_INCLUDED +#define BOOST_MPL_CONTAINS_HPP_INCLUDED + +// Copyright Eric Friedman 2002 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/contains.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct contains + : contains_impl< typename sequence_tag::type > + ::template apply< Sequence,T > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,contains,(Sequence,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, contains) + +}} + +#endif // BOOST_MPL_CONTAINS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/contains_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/contains_fwd.hpp new file mode 100644 index 0000000000..5e07408221 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/contains_fwd.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED +#define BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED + +// Copyright Eric Friedman 2002 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/contains_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct contains_impl; +template< typename Sequence, typename T > struct contains; + +}} + +#endif // BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/copy.hpp b/deal.II/contrib/boost/include/boost/mpl/copy.hpp new file mode 100644 index 0000000000..8045aaab61 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/copy.hpp @@ -0,0 +1,58 @@ + +#ifndef BOOST_MPL_COPY_HPP_INCLUDED +#define BOOST_MPL_COPY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/copy.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Sequence + , typename Inserter + > +struct copy_impl + : fold< + Sequence + , typename Inserter::state + , typename Inserter::operation + > +{ +}; + +template< + typename Sequence + , typename Inserter + > +struct reverse_copy_impl + : reverse_fold< + Sequence + , typename Inserter::state + , typename Inserter::operation + > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(2, copy) + +}} + +#endif // BOOST_MPL_COPY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/copy_if.hpp b/deal.II/contrib/boost/include/boost/mpl/copy_if.hpp new file mode 100644 index 0000000000..1bfd84b222 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/copy_if.hpp @@ -0,0 +1,96 @@ + +#ifndef BOOST_MPL_COPY_IF_HPP_INCLUDED +#define BOOST_MPL_COPY_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/copy_if.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Operation + , typename Predicate + > +struct copy_if_op +{ + template< typename Sequence, typename T > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : eval_if< + typename apply1::type + , apply2 + , identity + > + { +#else + { + typedef typename eval_if< + typename apply1::type + , apply2 + , identity + >::type type; +#endif + }; +}; + +template< + typename Sequence + , typename Predicate + , typename Inserter + > +struct copy_if_impl + : fold< + Sequence + , typename Inserter::state + , protect< aux::copy_if_op< + typename Inserter::operation + , Predicate + > > + > +{ +}; + +template< + typename Sequence + , typename Predicate + , typename Inserter + > +struct reverse_copy_if_impl + : reverse_fold< + Sequence + , typename Inserter::state + , protect< aux::copy_if_op< + typename Inserter::operation + , Predicate + > > + > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, copy_if) + +}} + +#endif // BOOST_MPL_COPY_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/count.hpp b/deal.II/contrib/boost/include/boost/mpl/count.hpp new file mode 100644 index 0000000000..6a0feea39e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/count.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_COUNT_HPP_INCLUDED +#define BOOST_MPL_COUNT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/count.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct count + : count_impl< typename sequence_tag::type > + ::template apply +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,count,(Sequence,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, count) + +}} + +#endif // BOOST_MPL_COUNT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/count_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/count_fwd.hpp new file mode 100644 index 0000000000..8dcb2311bd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/count_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_COUNT_FWD_HPP_INCLUDED +#define BOOST_MPL_COUNT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/count_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct count_impl; +template< typename Sequence, typename T > struct count; + +}} + +#endif // BOOST_MPL_COUNT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/count_if.hpp b/deal.II/contrib/boost/include/boost/mpl/count_if.hpp new file mode 100644 index 0000000000..5d20cec301 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/count_if.hpp @@ -0,0 +1,79 @@ + +#ifndef BOOST_MPL_COUNT_IF_HPP_INCLUDED +#define BOOST_MPL_COUNT_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/count_if.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< typename Predicate > +struct next_if +{ + template< + typename N + , typename T + > + struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : eval_if< + typename apply1::type + , next + , identity + > + { +#else + { + typedef typename eval_if< + typename apply1::type + , next + , identity + >::type type; +#endif + }; +}; + +} // namespace aux + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Predicate) + > +struct count_if + : aux::msvc_eti_base< typename fold< + Sequence + , integral_c + , protect< aux::next_if > + >::type > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,count_if,(Sequence,Predicate)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, count_if) + +}} + +#endif // BOOST_MPL_COUNT_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/deque.hpp b/deal.II/contrib/boost/include/boost/mpl/deque.hpp new file mode 100644 index 0000000000..40d9f53671 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/deque.hpp @@ -0,0 +1,58 @@ + +#ifndef BOOST_MPL_DEQUE_HPP_INCLUDED +#define BOOST_MPL_DEQUE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/deque.hpp,v $ +// $Date: 2004/11/28 01:53:40 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_DEQUE_HEADER \ + BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE).hpp \ + /**/ +#else +# define AUX778076_DEQUE_HEADER \ + BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_DEQUE_HEADER) +# undef AUX778076_DEQUE_HEADER +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER deque.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME deque +# define AUX778076_SEQUENCE_BASE_NAME vector +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_DEQUE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/deref.hpp b/deal.II/contrib/boost/include/boost/mpl/deref.hpp new file mode 100644 index 0000000000..3705540d78 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/deref.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_DEREF_HPP_INCLUDED +#define BOOST_MPL_DEREF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/deref.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Iterator) + > +struct deref +{ +#if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) + typedef typename Iterator::type type; +#else + typedef typename aux::msvc_type::type type; +#endif + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,deref,(Iterator)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, deref) + +}} + +#endif // BOOST_MPL_DEREF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/distance.hpp b/deal.II/contrib/boost/include/boost/mpl/distance.hpp new file mode 100644 index 0000000000..7d16862930 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/distance.hpp @@ -0,0 +1,78 @@ + +#ifndef BOOST_MPL_DISTANCE_HPP_INCLUDED +#define BOOST_MPL_DISTANCE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/distance.hpp,v $ +// $Date: 2005/01/26 01:58:33 $ +// $Revision: 1.10 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace boost { namespace mpl { + +// default implementation for forward/bidirectional iterators +template< typename Tag > struct distance_impl +{ + template< typename First, typename Last > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : aux::msvc_eti_base< typename iter_fold< + iterator_range + , mpl::long_<0> + , next<> + >::type > + { +#else + { + typedef typename iter_fold< + iterator_range + , mpl::long_<0> + , next<> + >::type type; + + BOOST_STATIC_CONSTANT(long, value = + (iter_fold< + iterator_range + , mpl::long_<0> + , next<> + >::type::value) + ); +#endif + }; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(First) + , typename BOOST_MPL_AUX_NA_PARAM(Last) + > +struct distance + : distance_impl< typename tag::type > + ::template apply +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, distance, (First, Last)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, distance) + +}} + +#endif // BOOST_MPL_DISTANCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/distance_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/distance_fwd.hpp new file mode 100644 index 0000000000..d0a419c34d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/distance_fwd.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED +#define BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/distance_fwd.hpp,v $ +// $Date: 2004/11/28 01:53:40 $ +// $Revision: 1.3 $ + +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_COMMON_NAME_WKND(distance) + +template< typename Tag > struct distance_impl; +template< typename First, typename Last > struct distance; + +}} + +#endif // BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/divides.hpp b/deal.II/contrib/boost/include/boost/mpl/divides.hpp new file mode 100644 index 0000000000..06f768b391 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/divides.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_DIVIDES_HPP_INCLUDED +#define BOOST_MPL_DIVIDES_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/divides.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME divides +#define AUX778076_OP_TOKEN / +#include + +#endif // BOOST_MPL_DIVIDES_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/empty.hpp b/deal.II/contrib/boost/include/boost/mpl/empty.hpp new file mode 100644 index 0000000000..244681dc8e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/empty.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_EMPTY_HPP_INCLUDED +#define BOOST_MPL_EMPTY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/empty.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct empty + : empty_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,empty,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, empty) + +}} + +#endif // BOOST_MPL_EMPTY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/empty_base.hpp b/deal.II/contrib/boost/include/boost/mpl/empty_base.hpp new file mode 100644 index 0000000000..0f45ce05a6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/empty_base.hpp @@ -0,0 +1,59 @@ + +#ifndef BOOST_MPL_EMPTY_BASE_HPP_INCLUDED +#define BOOST_MPL_EMPTY_BASE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/empty_base.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include + +#include + +// should be always the last #include directive +#include + +namespace boost { namespace mpl { + +// empty base class, guaranteed to have no members; inheritance from +// 'empty_base' through the 'inherit' metafunction is a no-op - see +// "mpl/inherit.hpp> header for the details +struct empty_base {}; + +template< typename T > +struct is_empty_base + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +template<> +struct is_empty_base + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +}} + +namespace boost { +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_empty, mpl::empty_base, true) +} + +#include + +#endif // BOOST_MPL_EMPTY_BASE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/empty_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/empty_fwd.hpp new file mode 100644 index 0000000000..f4313c1abf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/empty_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_EMPTY_FWD_HPP_INCLUDED +#define BOOST_MPL_EMPTY_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/empty_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct empty_impl; +template< typename Sequence > struct empty; + +}} + +#endif // BOOST_MPL_EMPTY_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/empty_sequence.hpp b/deal.II/contrib/boost/include/boost/mpl/empty_sequence.hpp new file mode 100644 index 0000000000..47e82c4442 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/empty_sequence.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_EMPTY_SEQUENCE_HPP_INCLUDED +#define BOOST_MPL_EMPTY_SEQUENCE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// Copyright Alexander Nasonov 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/empty_sequence.hpp,v $ +// $Date: 2004/11/28 01:53:40 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +struct empty_sequence +{ + struct tag; + struct begin { typedef random_access_iterator_tag category; }; + typedef begin end; +}; + +template<> +struct size_impl +{ + template< typename Sequence > struct apply + : int_<0> + { + }; +}; + +}} + +#endif // #ifndef BOOST_MPL_EMPTY_SEQUENCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/end.hpp b/deal.II/contrib/boost/include/boost/mpl/end.hpp new file mode 100644 index 0000000000..d052dbf4d3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/end.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_END_HPP_INCLUDED +#define BOOST_MPL_END_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/end.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include + +#endif // BOOST_MPL_END_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/equal.hpp b/deal.II/contrib/boost/include/boost/mpl/equal.hpp new file mode 100644 index 0000000000..671c9ae2fb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/equal.hpp @@ -0,0 +1,112 @@ + +#ifndef BOOST_MPL_EQUAL_HPP_INCLUDED +#define BOOST_MPL_EQUAL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/equal.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Predicate + , typename LastIterator1 + , typename LastIterator2 + > +struct equal_pred +{ + template< + typename Iterator2 + , typename Iterator1 + > + struct apply + { + typedef typename and_< + not_< is_same > + , not_< is_same > + , aux::iter_apply2 + >::type type; + }; +}; + +template< + typename Sequence1 + , typename Sequence2 + , typename Predicate + > +struct equal_impl +{ + typedef typename begin::type first1_; + typedef typename begin::type first2_; + typedef typename end::type last1_; + typedef typename end::type last2_; + + typedef aux::iter_fold_if_impl< + first1_ + , first2_ + , next<> + , protect< aux::equal_pred > + , void_ + , always + > fold_; + + typedef typename fold_::iterator iter1_; + typedef typename fold_::state iter2_; + typedef and_< + is_same + , is_same + > result_; + + typedef typename result_::type type; +}; + + +} // namespace aux + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence1) + , typename BOOST_MPL_AUX_NA_PARAM(Sequence2) + , typename Predicate = is_same<_,_> + > +struct equal + : aux::msvc_eti_base< + typename aux::equal_impl::type + >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,equal,(Sequence1,Sequence2)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, equal) + +}} + +#endif // BOOST_MPL_EQUAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/equal_to.hpp new file mode 100644 index 0000000000..fb9be1bd0f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/equal_to.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_EQUAL_TO_HPP_INCLUDED +#define BOOST_MPL_EQUAL_TO_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/equal_to.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME equal_to +#define AUX778076_OP_TOKEN == +#include + +#endif // BOOST_MPL_EQUAL_TO_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/erase.hpp b/deal.II/contrib/boost/include/boost/mpl/erase.hpp new file mode 100644 index 0000000000..cf6104e0fb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/erase.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_ERASE_HPP_INCLUDED +#define BOOST_MPL_ERASE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/erase.hpp,v $ +// $Date: 2004/11/28 01:54:10 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(First) + , typename BOOST_MPL_AUX_NA_PARAM(Last) + > +struct erase + : erase_impl< typename sequence_tag::type > + ::template apply< Sequence,First,Last > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,erase,(Sequence,First,Last)) +}; + +BOOST_MPL_AUX_NA_SPEC(3,erase) + +}} + +#endif // BOOST_MPL_ERASE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/erase_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/erase_fwd.hpp new file mode 100644 index 0000000000..02a50a1967 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/erase_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_ERASE_FWD_HPP_INCLUDED +#define BOOST_MPL_ERASE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/erase_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct erase_impl; +template< typename Sequence, typename First, typename Last > struct erase; + +}} + +#endif // BOOST_MPL_ERASE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/erase_key.hpp b/deal.II/contrib/boost/include/boost/mpl/erase_key.hpp new file mode 100644 index 0000000000..8a89e5d5ca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/erase_key.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_ERASE_KEY_HPP_INCLUDED +#define BOOST_MPL_ERASE_KEY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/erase_key.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Key) + > +struct erase_key + : erase_key_impl< typename sequence_tag::type > + ::template apply< Sequence,Key > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,erase_key,(Sequence,Key)) +}; + +BOOST_MPL_AUX_NA_SPEC(2,erase_key) + +}} + +#endif // BOOST_MPL_ERASE_KEY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/erase_key_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/erase_key_fwd.hpp new file mode 100644 index 0000000000..12c7c5d666 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/erase_key_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_ERASE_KEY_FWD_HPP_INCLUDED +#define BOOST_MPL_ERASE_KEY_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/erase_key_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct erase_key_impl; +template< typename Sequence, typename Key > struct erase_key; + +}} + +#endif // BOOST_MPL_ERASE_KEY_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/eval_if.hpp b/deal.II/contrib/boost/include/boost/mpl/eval_if.hpp index cf97d6daf1..14d1e371e2 100644 --- a/deal.II/contrib/boost/include/boost/mpl/eval_if.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/eval_if.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/eval_if.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/filter_view.hpp b/deal.II/contrib/boost/include/boost/mpl/filter_view.hpp new file mode 100644 index 0000000000..67c81905d8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/filter_view.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_FILTER_VIEW_HPP_INCLUDED +#define BOOST_MPL_FILTER_VIEW_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/filter_view.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Predicate) + > +struct filter_view +{ + private: + typedef typename lambda::type pred_; + typedef typename begin::type first_; + typedef typename end::type last_; + + public: + struct tag; + typedef filter_view type; + typedef typename aux::next_filter_iter< first_,last_,pred_ >::type begin; + typedef aux::filter_iter< last_,last_,pred_ > end; +}; + +BOOST_MPL_AUX_NA_SPEC(2, filter_view) + +}} + +#endif // BOOST_MPL_FILTER_VIEW_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/find.hpp b/deal.II/contrib/boost/include/boost/mpl/find.hpp new file mode 100644 index 0000000000..a77f3cc9d2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/find.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_FIND_HPP_INCLUDED +#define BOOST_MPL_FIND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/find.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct find + : find_if< Sequence,same_as > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,find,(Sequence,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, find) + +}} + +#endif // BOOST_MPL_FIND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/find_if.hpp b/deal.II/contrib/boost/include/boost/mpl/find_if.hpp new file mode 100644 index 0000000000..db06ecc317 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/find_if.hpp @@ -0,0 +1,50 @@ + +#ifndef BOOST_MPL_FIND_IF_HPP_INCLUDED +#define BOOST_MPL_FIND_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/find_if.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.10 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_COMMON_NAME_WKND(find_if) + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Predicate) + > +struct find_if +{ + typedef typename iter_fold_if< + Sequence + , void + , arg<1> // ignore + , protect< aux::find_if_pred > + >::type result_; + + typedef typename second::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,find_if,(Sequence,Predicate)) +}; + +BOOST_MPL_AUX_NA_SPEC(2,find_if) + +}} + +#endif // BOOST_MPL_FIND_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/fold.hpp b/deal.II/contrib/boost/include/boost/mpl/fold.hpp new file mode 100644 index 0000000000..69fa823bb5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/fold.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_FOLD_HPP_INCLUDED +#define BOOST_MPL_FOLD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/fold.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(State) + , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) + > +struct fold +{ + typedef typename aux::fold_impl< + ::boost::mpl::O1_size::value + , typename begin::type + , typename end::type + , State + , ForwardOp + >::state type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,fold,(Sequence,State,ForwardOp)) +}; + +BOOST_MPL_AUX_NA_SPEC(3, fold) + +}} + +#endif // BOOST_MPL_FOLD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/for_each.hpp b/deal.II/contrib/boost/include/boost/mpl/for_each.hpp new file mode 100644 index 0000000000..b87deb67b0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/for_each.hpp @@ -0,0 +1,112 @@ + +#ifndef BOOST_MPL_FOR_EACH_HPP_INCLUDED +#define BOOST_MPL_FOR_EACH_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/for_each.hpp,v $ +// $Date: 2004/09/04 01:33:46 $ +// $Revision: 1.9 $ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< bool done = true > +struct for_each_impl +{ + template< + typename Iterator + , typename LastIterator + , typename TransformFunc + , typename F + > + static void execute( + Iterator* + , LastIterator* + , TransformFunc* + , F + ) + { + } +}; + +template<> +struct for_each_impl +{ + template< + typename Iterator + , typename LastIterator + , typename TransformFunc + , typename F + > + static void execute( + Iterator* + , LastIterator* + , TransformFunc* + , F f + ) + { + typedef typename deref::type item; + typedef typename apply1::type arg; + + // dwa 2002/9/10 -- make sure not to invoke undefined behavior + // when we pass arg. + value_initialized x; + aux::unwrap(f, 0)(boost::get(x)); + + typedef typename mpl::next::type iter; + for_each_impl::value> + ::execute((iter*)0, (LastIterator*)0, (TransformFunc*)0, f); + } +}; + +} // namespace aux + +// agurt, 17/mar/02: pointer default parameters are necessary to workaround +// MSVC 6.5 function template signature's mangling bug +template< + typename Sequence + , typename TransformOp + , typename F + > +inline +void for_each(F f, Sequence* = 0, TransformOp* = 0) +{ + typedef typename begin::type first; + typedef typename end::type last; + + aux::for_each_impl< boost::is_same::value > + ::execute((first*)0, (last*)0, (TransformOp*)0, f); +} + +template< + typename Sequence + , typename F + > +inline +void for_each(F f, Sequence* = 0) +{ + for_each >(f); +} + +}} + +#endif // BOOST_MPL_FOR_EACH_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/front.hpp b/deal.II/contrib/boost/include/boost/mpl/front.hpp new file mode 100644 index 0000000000..cfcdcaac80 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/front.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_FRONT_HPP_INCLUDED +#define BOOST_MPL_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/front.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct front + : front_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,front,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, front) + +}} + +#endif // BOOST_MPL_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/front_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/front_fwd.hpp new file mode 100644 index 0000000000..158210a45a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/front_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_FRONT_FWD_HPP_INCLUDED +#define BOOST_MPL_FRONT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/front_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct front_impl; +template< typename Sequence > struct front; + +}} + +#endif // BOOST_MPL_FRONT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/front_inserter.hpp b/deal.II/contrib/boost/include/boost/mpl/front_inserter.hpp new file mode 100644 index 0000000000..44d864e4dc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/front_inserter.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED +#define BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/front_inserter.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template< + typename Sequence + > +struct front_inserter + : inserter< Sequence,push_front<> > +{ +}; + +}} + +#endif // BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/greater.hpp b/deal.II/contrib/boost/include/boost/mpl/greater.hpp new file mode 100644 index 0000000000..a76e5f85e0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/greater.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_GREATER_HPP_INCLUDED +#define BOOST_MPL_GREATER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/greater.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME greater +#define AUX778076_OP_TOKEN > +#include + +#endif // BOOST_MPL_GREATER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/greater_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/greater_equal.hpp new file mode 100644 index 0000000000..9f9151de21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/greater_equal.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED +#define BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/greater_equal.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME greater_equal +#define AUX778076_OP_TOKEN >= +#include + +#endif // BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/has_key.hpp b/deal.II/contrib/boost/include/boost/mpl/has_key.hpp new file mode 100644 index 0000000000..d1cbe8832d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/has_key.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_HAS_KEY_HPP_INCLUDED +#define BOOST_MPL_HAS_KEY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/has_key.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) + , typename BOOST_MPL_AUX_NA_PARAM(Key) + > +struct has_key + : has_key_impl< typename sequence_tag::type > + ::template apply +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,has_key,(AssociativeSequence,Key)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, has_key) + +}} + +#endif // BOOST_MPL_HAS_KEY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/has_key_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/has_key_fwd.hpp new file mode 100644 index 0000000000..49ecb1f6ef --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/has_key_fwd.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_HAS_KEY_FWD_HPP_INCLUDED +#define BOOST_MPL_HAS_KEY_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/has_key_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct has_key_impl; +template< typename AssociativeSequence, typename Key > struct has_key; + +}} + +#endif // BOOST_MPL_HAS_KEY_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/has_xxx.hpp b/deal.II/contrib/boost/include/boost/mpl/has_xxx.hpp new file mode 100644 index 0000000000..9203f33d98 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/has_xxx.hpp @@ -0,0 +1,232 @@ + +#ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED +#define BOOST_MPL_HAS_XXX_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// Copyright David Abrahams 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/has_xxx.hpp,v $ +// $Date: 2005/06/15 10:43:23 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) + +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +// agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET +// newsgroup's posting by John Madsen (comp.lang.c++.moderated, +// 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but +// it works way more reliably than the SFINAE-based implementation + +// Modified dwa 8/Oct/02 to handle reference types. + +# include +# include + +namespace boost { namespace mpl { namespace aux { + +struct has_xxx_tag; + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) +template< typename U > struct msvc_incomplete_array +{ + typedef char (&type)[sizeof(U) + 1]; +}; +#endif + +template< typename T > +struct msvc_is_incomplete +{ + // MSVC is capable of some kinds of SFINAE. If U is an incomplete + // type, it won't pick the second overload + static char tester(...); + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) + template< typename U > + static typename msvc_incomplete_array::type tester(type_wrapper); +#else + template< typename U > + static char (& tester(type_wrapper) )[sizeof(U)+1]; +#endif + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(tester(type_wrapper())) == 1 + ); +}; + +template<> +struct msvc_is_incomplete +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +}}} + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \ +template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \ +struct BOOST_PP_CAT(trait,_impl) : T \ +{ \ + static boost::mpl::aux::no_tag \ + test(void(*)(::boost::mpl::aux::has_xxx_tag)); \ + \ + static boost::mpl::aux::yes_tag test(...); \ + \ + BOOST_STATIC_CONSTANT(bool, value = \ + sizeof(test(static_cast(0))) \ + != sizeof(boost::mpl::aux::no_tag) \ + ); \ + typedef boost::mpl::bool_ type; \ +}; \ +\ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ + : boost::mpl::if_c< \ + boost::mpl::aux::msvc_is_incomplete::value \ + , boost::mpl::bool_ \ + , BOOST_PP_CAT(trait,_impl) \ + >::type \ +{ \ +}; \ +\ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \ +/**/ + +# define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \ +template<> struct trait \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = false); \ + typedef boost::mpl::bool_ type; \ +}; \ +/**/ + +#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ + BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \ +/**/ +#else +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ +/**/ +#endif + + +// SFINAE-based implementations below are derived from a USENET newsgroup's +// posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST) + +# elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) + +// MSVC 7.1+ + +// agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE +// applied to partial specialization to fix some apparently random failures +// (thanks to Daniel Wallin for researching this!) + +namespace boost { namespace mpl { namespace aux { +template< typename T > struct msvc71_sfinae_helper { typedef void type; }; +}}} + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ +template< typename T, typename U = void > \ +struct BOOST_PP_CAT(trait,_impl_) \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = false); \ + typedef boost::mpl::bool_ type; \ +}; \ +\ +template< typename T > \ +struct BOOST_PP_CAT(trait,_impl_)< \ + T \ + , typename boost::mpl::aux::msvc71_sfinae_helper< typename T::name >::type \ + > \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = true); \ + typedef boost::mpl::bool_ type; \ +}; \ +\ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ + : BOOST_PP_CAT(trait,_impl_) \ +{ \ +}; \ +/**/ + +# else // other SFINAE-capable compilers + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ +{ \ + struct gcc_3_2_wknd \ + { \ + template< typename U > \ + static boost::mpl::aux::yes_tag test( \ + boost::mpl::aux::type_wrapper const volatile* \ + , boost::mpl::aux::type_wrapper* = 0 \ + ); \ + \ + static boost::mpl::aux::no_tag test(...); \ + }; \ + \ + typedef boost::mpl::aux::type_wrapper t_; \ + BOOST_STATIC_CONSTANT(bool, value = \ + sizeof(gcc_3_2_wknd::test(static_cast(0))) \ + == sizeof(boost::mpl::aux::yes_tag) \ + ); \ + typedef boost::mpl::bool_ type; \ +}; \ +/**/ + +# endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + +#else // BOOST_MPL_CFG_NO_HAS_XXX + +// placeholder implementation + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ + typedef fallback_ type; \ +}; \ +/**/ + +#endif + +#define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \ +/**/ + +#endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/identity.hpp b/deal.II/contrib/boost/include/boost/mpl/identity.hpp index 1eaa9a4596..17875463ab 100644 --- a/deal.II/contrib/boost/include/boost/mpl/identity.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/identity.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/identity.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/if.hpp b/deal.II/contrib/boost/include/boost/mpl/if.hpp index 9b4f999654..a66a4de09f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/if.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/if.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/if.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/index_if.hpp b/deal.II/contrib/boost/include/boost/mpl/index_if.hpp new file mode 100644 index 0000000000..fa627ad8b1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/index_if.hpp @@ -0,0 +1,60 @@ + +#ifndef BOOST_MPL_INDEX_IF_HPP_INCLUDED +#define BOOST_MPL_INDEX_IF_HPP_INCLUDED + +// Copyright Eric Friedman 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/index_if.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Predicate) + > +struct index_if +{ + typedef typename iter_fold_if< + Sequence + , int_<0> + , next<> + , aux::find_if_pred + >::type result_; + + typedef typename end::type not_found_; + typedef typename first::type result_index_; + typedef typename second::type result_iterator_; + + typedef typename if_< + is_same< result_iterator_,not_found_ > + , void_ + , result_index_ + >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,index_if,(Sequence,Predicate)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, index_if) + +}} + +#endif // BOOST_MPL_INDEX_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/index_of.hpp b/deal.II/contrib/boost/include/boost/mpl/index_of.hpp new file mode 100644 index 0000000000..f77bd24b7d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/index_of.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_INDEX_OF_HPP_INCLUDED +#define BOOST_MPL_INDEX_OF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright Eric Friedman 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/index_of.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct index_of + : index_if< Sequence,same_as > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,index_of,(Sequence,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, index_of) + +}} + +#endif // BOOST_MPL_INDEX_OF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/inherit.hpp b/deal.II/contrib/boost/include/boost/mpl/inherit.hpp new file mode 100644 index 0000000000..43b41cec2d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/inherit.hpp @@ -0,0 +1,229 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_INHERIT_HPP_INCLUDED +#define BOOST_MPL_INHERIT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/inherit.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER inherit.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + +# include +# include +# include + +namespace boost { namespace mpl { + +// 'inherit' metafunction; returns an unspecified class type +// produced by public derivation from all metafunction's parameters +// (T1,T2,..,Tn), except the parameters of 'empty_base' class type; +// regardless the position and number of 'empty_base' parameters in the +// metafunction's argument list, derivation from them is always a no-op; +// for instance: +// inherit::type == her +// inherit::type == struct unspecified : her, my {}; +// inherit::type == her +// inherit::type == her +// inherit::type == struct unspecified : her, my {}; +// inherit::type == empty_base + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : T1, T2 +{ + typedef inherit2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1,T2)) +}; + +template< typename T1 > +struct inherit2 +{ + typedef T1 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1,empty_base)) +}; + +template< typename T2 > +struct inherit2 +{ + typedef T2 type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base,T2)) +}; + +// needed to disambiguate the previous two in case when both +// T1 and T2 == empty_base +template<> +struct inherit2 +{ + typedef empty_base type; + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base,empty_base)) +}; + +#else + +namespace aux { + +template< bool C1, bool C2 > +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1, T2 + { + typedef Derived type_; + }; +}; + +template<> +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T1 + { + typedef T1 type_; + }; +}; + +template<> +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + : T2 + { + typedef T2 type_; + }; +}; + +template<> +struct inherit2_impl +{ + template< typename Derived, typename T1, typename T2 > struct result_ + { + typedef T1 type_; + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct inherit2 + : aux::inherit2_impl< + is_empty_base::value + , is_empty_base::value + >::template result_< inherit2,T1,T2 > +{ + typedef typename inherit2::type_ type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1,T2)) +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_MPL_AUX_NA_SPEC(2, inherit2) + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(3, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_INHERIT_HPP_INCLUDED + +///// iteration + +#else +#define n_ BOOST_PP_FRAME_ITERATION(1) + +template< + BOOST_MPL_PP_DEFAULT_PARAMS(n_, typename T, na) + > +struct BOOST_PP_CAT(inherit,n_) + : inherit2< + typename BOOST_PP_CAT(inherit,BOOST_PP_DEC(n_))< + BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(n_), T) + >::type + , BOOST_PP_CAT(T,n_) + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + n_ + , BOOST_PP_CAT(inherit,n_) + , (BOOST_MPL_PP_PARAMS(n_, T)) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(n_, BOOST_PP_CAT(inherit,n_)) + +#if n_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY +/// primary template +template< + BOOST_MPL_PP_DEFAULT_PARAMS(n_, typename T, empty_base) + > +struct inherit + : BOOST_PP_CAT(inherit,n_) +{ +}; + +// 'na' specialization +template<> +struct inherit< BOOST_MPL_PP_ENUM(5, na) > +{ + template< +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) + BOOST_MPL_PP_DEFAULT_PARAMS(n_, typename T, empty_base) +#else + BOOST_MPL_PP_PARAMS(n_, typename T) +#endif + > + struct apply + : inherit< BOOST_MPL_PP_PARAMS(n_, T) > + { + }; +}; + +BOOST_MPL_AUX_NA_SPEC_LAMBDA(n_, inherit) +BOOST_MPL_AUX_NA_SPEC_ARITY(n_, inherit) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(n_, n_, inherit) +#endif + +#undef n_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/inherit_linearly.hpp b/deal.II/contrib/boost/include/boost/mpl/inherit_linearly.hpp new file mode 100644 index 0000000000..8575f3166c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/inherit_linearly.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_INHERIT_FRONT_TO_BACK_HPP_INCLUDED +#define BOOST_MPL_INHERIT_FRONT_TO_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/inherit_linearly.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Types_) + , typename BOOST_MPL_AUX_NA_PARAM(Node_) + , typename Root_ = empty_base + > +struct inherit_linearly + : fold +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,inherit_linearly,(Types_,Node_,Root_)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, inherit_linearly) + +}} + +#endif // BOOST_MPL_INHERIT_FRONT_TO_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/insert.hpp b/deal.II/contrib/boost/include/boost/mpl/insert.hpp new file mode 100644 index 0000000000..7b8e3df6bd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/insert.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_INSERT_HPP_INCLUDED +#define BOOST_MPL_INSERT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/insert.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Pos_or_T) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct insert + : insert_impl< typename sequence_tag::type > + ::template apply< Sequence,Pos_or_T,T > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert,(Sequence,Pos_or_T,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(3, insert) + +}} + +#endif // BOOST_MPL_INSERT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/insert_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/insert_fwd.hpp new file mode 100644 index 0000000000..b106315320 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/insert_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_INSERT_FWD_HPP_INCLUDED +#define BOOST_MPL_INSERT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/insert_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct insert_impl; +template< typename Sequence, typename Pos_or_T, typename T > struct insert; + +}} + +#endif // BOOST_MPL_INSERT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/insert_range.hpp b/deal.II/contrib/boost/include/boost/mpl/insert_range.hpp new file mode 100644 index 0000000000..79bb227c3c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/insert_range.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_INSERT_RANGE_HPP_INCLUDED +#define BOOST_MPL_INSERT_RANGE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/insert_range.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Pos) + , typename BOOST_MPL_AUX_NA_PARAM(Range) + > +struct insert_range + : insert_range_impl< typename sequence_tag::type > + ::template apply< Sequence,Pos,Range > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert_range,(Sequence,Pos,Range)) +}; + +BOOST_MPL_AUX_NA_SPEC(3, insert_range) + +}} + +#endif // BOOST_MPL_INSERT_RANGE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/insert_range_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/insert_range_fwd.hpp new file mode 100644 index 0000000000..5a2a711aca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/insert_range_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED +#define BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/insert_range_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct insert_range_impl; +template< typename Sequence, typename Pos, typename Range > struct insert_range; + +}} + +#endif // BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/inserter.hpp b/deal.II/contrib/boost/include/boost/mpl/inserter.hpp new file mode 100644 index 0000000000..e09c6ec0d0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/inserter.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_INSERTER_HPP_INCLUDED +#define BOOST_MPL_INSERTER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/inserter.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { + +template< + typename Sequence + , typename Operation + > +struct inserter +{ + typedef Sequence state; + typedef Operation operation; +}; + +}} + +#endif // BOOST_MPL_INSERTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/int.hpp b/deal.II/contrib/boost/include/boost/mpl/int.hpp index e6d99344a1..53b9ba0e9a 100644 --- a/deal.II/contrib/boost/include/boost/mpl/int.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/int.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/int.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp index 738ae160fd..4769b1801a 100644 --- a/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/int_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/integral_c.hpp b/deal.II/contrib/boost/include/boost/mpl/integral_c.hpp index d7abd126e0..dfdf6882a0 100644 --- a/deal.II/contrib/boost/include/boost/mpl/integral_c.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/integral_c.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/integral_c.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/integral_c_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/integral_c_fwd.hpp index 38146c3408..7c95c5569f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/integral_c_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/integral_c_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/integral_c_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/integral_c_tag.hpp b/deal.II/contrib/boost/include/boost/mpl/integral_c_tag.hpp index 14f3c385d1..2c04ecff7f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/integral_c_tag.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/integral_c_tag.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/integral_c_tag.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/is_placeholder.hpp b/deal.II/contrib/boost/include/boost/mpl/is_placeholder.hpp new file mode 100644 index 0000000000..9618e31b2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/is_placeholder.hpp @@ -0,0 +1,67 @@ + +#ifndef BOOST_MPL_IS_PLACEHOLDER_HPP_INCLUDED +#define BOOST_MPL_IS_PLACEHOLDER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/is_placeholder.hpp,v $ +// $Date: 2004/09/07 08:51:31 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename T > +struct is_placeholder + : bool_ +{ +}; + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct is_placeholder< arg > + : bool_ +{ +}; + +#else + +namespace aux { + +aux::no_tag is_placeholder_helper(...); + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > +aux::yes_tag is_placeholder_helper(aux::type_wrapper< arg >*); + +} // namespace aux + +template< typename T > +struct is_placeholder +{ + static aux::type_wrapper* get(); + BOOST_STATIC_CONSTANT(bool, value = + sizeof(aux::is_placeholder_helper(get())) == sizeof(aux::yes_tag) + ); + + typedef bool_ type; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +}} + +#endif // BOOST_MPL_IS_PLACEHOLDER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/is_sequence.hpp b/deal.II/contrib/boost/include/boost/mpl/is_sequence.hpp new file mode 100644 index 0000000000..08b3b87c7d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/is_sequence.hpp @@ -0,0 +1,112 @@ + +#ifndef BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED +#define BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/is_sequence.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) +# include +#elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) +# include +#endif + +#include + +namespace boost { namespace mpl { + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +namespace aux { + +// agurt, 11/jun/03: +// MSVC 6.5/7.0 fails if 'has_begin' is instantiated on a class type that has a +// 'begin' member that doesn't name a type; e.g. 'has_begin< std::vector >' +// would fail; requiring 'T' to have _both_ 'tag' and 'begin' members workarounds +// the issue for most real-world cases +template< typename T > struct is_sequence_impl + : and_< + identity< aux::has_tag > + , identity< aux::has_begin > + > +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct is_sequence + : if_< +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + aux::msvc_is_class +#else + boost::is_class +#endif + , aux::is_sequence_impl + , bool_ + >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, is_sequence, (T)) +}; + +#elif defined(BOOST_MPL_CFG_NO_HAS_XXX) + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct is_sequence + : bool_ +{ +}; + +#else + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct is_sequence + : not_< is_same< typename begin::type, void_ > > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, is_sequence, (T)) +}; + +#endif // BOOST_MSVC + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) +template<> struct is_sequence + : bool_ +{ +}; +#endif + +BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, is_sequence) + +}} + +#endif // BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/iter_fold.hpp b/deal.II/contrib/boost/include/boost/mpl/iter_fold.hpp new file mode 100644 index 0000000000..59978de687 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/iter_fold.hpp @@ -0,0 +1,49 @@ + +#ifndef BOOST_MPL_ITER_FOLD_HPP_INCLUDED +#define BOOST_MPL_ITER_FOLD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/iter_fold.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(State) + , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) + > +struct iter_fold +{ + typedef typename aux::iter_fold_impl< + ::boost::mpl::O1_size::value + , typename begin::type + , typename end::type + , State + , typename lambda::type + >::state type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,iter_fold,(Sequence,State,ForwardOp)) +}; + +BOOST_MPL_AUX_NA_SPEC(3, iter_fold) + +}} + +#endif // BOOST_MPL_ITER_FOLD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/iter_fold_if.hpp b/deal.II/contrib/boost/include/boost/mpl/iter_fold_if.hpp new file mode 100644 index 0000000000..3328c9d1a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/iter_fold_if.hpp @@ -0,0 +1,117 @@ + +#ifndef BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED +#define BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright Eric Friedman 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/iter_fold_if.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< typename Predicate, typename LastIterator > +struct iter_fold_if_pred +{ + template< typename State, typename Iterator > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : and_< + not_< is_same > + , apply1 + > + { +#else + { + typedef and_< + not_< is_same > + , apply1 + > type; +#endif + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(State) + , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) + , typename BOOST_MPL_AUX_NA_PARAM(ForwardPredicate) + , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp) + , typename BOOST_MPL_AUX_NA_PARAM(BackwardPredicate) + > +struct iter_fold_if +{ + + typedef typename begin::type first_; + typedef typename end::type last_; + + typedef typename eval_if< + is_na + , if_< is_na, always, always > + , identity + >::type backward_pred_; + +// cwpro8 doesn't like 'cut-off' type here (use typedef instead) +#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) && !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) + struct result_ : +#else + typedef +#endif + aux::iter_fold_if_impl< + first_ + , State + , ForwardOp + , protect< aux::iter_fold_if_pred< ForwardPredicate,last_ > > + , BackwardOp + , backward_pred_ + > +#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) && !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) + { }; +#else + result_; +#endif + +public: + + typedef pair< + typename result_::state + , typename result_::iterator + > type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 6 + , iter_fold_if + , (Sequence,State,ForwardOp,ForwardPredicate,BackwardOp,BackwardPredicate) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(6, iter_fold_if) + +}} + +#endif // BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/iterator_category.hpp b/deal.II/contrib/boost/include/boost/mpl/iterator_category.hpp new file mode 100644 index 0000000000..f522d74be9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/iterator_category.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_ITERATOR_CATEGORY_HPP_INCLUDED +#define BOOST_MPL_ITERATOR_CATEGORY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/iterator_category.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.6 $ + +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Iterator) + > +struct iterator_category +{ + typedef typename Iterator::category type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,iterator_category,(Iterator)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, iterator_category) + +}} + +#endif // BOOST_MPL_ITERATOR_CATEGORY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/iterator_range.hpp b/deal.II/contrib/boost/include/boost/mpl/iterator_range.hpp new file mode 100644 index 0000000000..ed6766d8c8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/iterator_range.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED +#define BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/iterator_range.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +struct iterator_range_tag; + +template< + typename BOOST_MPL_AUX_NA_PARAM(First) + , typename BOOST_MPL_AUX_NA_PARAM(Last) + > +struct iterator_range +{ + typedef iterator_range_tag tag; + typedef iterator_range type; + typedef First begin; + typedef Last end; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,iterator_range,(First,Last)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, iterator_range) + +}} + +#endif // BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/iterator_tags.hpp b/deal.II/contrib/boost/include/boost/mpl/iterator_tags.hpp new file mode 100644 index 0000000000..93a8256ea6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/iterator_tags.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED +#define BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/iterator_tags.hpp,v $ +// $Date: 2004/11/28 01:54:51 $ +// $Revision: 1.3 $ + +#include + +namespace boost { namespace mpl { + +struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; }; +struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; }; +struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; }; + +}} + +#endif // BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/joint_view.hpp b/deal.II/contrib/boost/include/boost/mpl/joint_view.hpp new file mode 100644 index 0000000000..5af5eb106e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/joint_view.hpp @@ -0,0 +1,65 @@ + +#ifndef BOOST_MPL_JOINT_VIEW_HPP_INCLUDED +#define BOOST_MPL_JOINT_VIEW_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/joint_view.hpp,v $ +// $Date: 2004/10/02 19:08:57 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { +struct joint_view_tag; +} + +template<> +struct size_impl< aux::joint_view_tag > +{ + template < typename JointView > struct apply + : plus< + size + , size + > + {}; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence1_) + , typename BOOST_MPL_AUX_NA_PARAM(Sequence2_) + > +struct joint_view +{ + typedef typename mpl::begin::type first1_; + typedef typename mpl::end::type last1_; + typedef typename mpl::begin::type first2_; + typedef typename mpl::end::type last2_; + + // agurt, 25/may/03: for the 'size_traits' implementation above + typedef Sequence1_ sequence1_; + typedef Sequence2_ sequence2_; + + typedef joint_view type; + typedef aux::joint_view_tag tag; + typedef joint_iter begin; + typedef joint_iter end; +}; + +BOOST_MPL_AUX_NA_SPEC(2, joint_view) + +}} + +#endif // BOOST_MPL_JOINT_VIEW_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/key_type.hpp b/deal.II/contrib/boost/include/boost/mpl/key_type.hpp new file mode 100644 index 0000000000..6e330bc048 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/key_type.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_KEY_TYPE_HPP_INCLUDED +#define BOOST_MPL_KEY_TYPE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/key_type.hpp,v $ +// $Date: 2004/12/14 22:34:44 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct key_type + : apply_wrap2< + key_type_impl< typename sequence_tag::type > + , AssociativeSequence, T> +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,key_type,(AssociativeSequence,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, key_type) + +}} + +#endif // BOOST_MPL_KEY_TYPE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/key_type_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/key_type_fwd.hpp new file mode 100644 index 0000000000..aad6313c0d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/key_type_fwd.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_KEY_TYPE_FWD_HPP_INCLUDED +#define BOOST_MPL_KEY_TYPE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/key_type_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct key_type_impl; +template< typename AssociativeSequence, typename T > struct key_type; + +}} + +#endif // BOOST_MPL_KEY_TYPE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/lambda.hpp new file mode 100644 index 0000000000..2f19eddc2c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/lambda.hpp @@ -0,0 +1,29 @@ + +#ifndef BOOST_MPL_LAMBDA_HPP_INCLUDED +#define BOOST_MPL_LAMBDA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/lambda.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# include +#else +# include +# include +# define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS +#endif + +#endif // BOOST_MPL_LAMBDA_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp index 78a72d9015..c549939b9f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/lambda_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/less.hpp b/deal.II/contrib/boost/include/boost/mpl/less.hpp new file mode 100644 index 0000000000..39fc27f570 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/less.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LESS_HPP_INCLUDED +#define BOOST_MPL_LESS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/less.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#define AUX778076_OP_NAME less +#define AUX778076_OP_TOKEN < +#include + +#endif // BOOST_MPL_LESS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/less_equal.hpp b/deal.II/contrib/boost/include/boost/mpl/less_equal.hpp new file mode 100644 index 0000000000..c36d479910 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/less_equal.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LESS_EQUAL_HPP_INCLUDED +#define BOOST_MPL_LESS_EQUAL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/less_equal.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME less_equal +#define AUX778076_OP_TOKEN <= +#include + +#endif // BOOST_MPL_LESS_EQUAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp index 9e03307024..ef25973134 100644 --- a/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/limits/arity.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/list.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/list.hpp new file mode 100644 index 0000000000..83c0ca37b5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/limits/list.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LIMITS_LIST_HPP_INCLUDED +#define BOOST_MPL_LIMITS_LIST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/limits/list.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.4 $ + +#if !defined(BOOST_MPL_LIMIT_LIST_SIZE) +# define BOOST_MPL_LIMIT_LIST_SIZE 20 +#endif + +#endif // BOOST_MPL_LIMITS_LIST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/map.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/map.hpp new file mode 100644 index 0000000000..16d9240f74 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/limits/map.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LIMITS_MAP_HPP_INCLUDED +#define BOOST_MPL_LIMITS_MAP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/limits/map.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_LIMIT_MAP_SIZE) +# define BOOST_MPL_LIMIT_MAP_SIZE 20 +#endif + +#endif // BOOST_MPL_LIMITS_MAP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/set.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/set.hpp new file mode 100644 index 0000000000..3ba1e64cb5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/limits/set.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LIMITS_SET_HPP_INCLUDED +#define BOOST_MPL_LIMITS_SET_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/limits/set.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_LIMIT_SET_SIZE) +# define BOOST_MPL_LIMIT_SET_SIZE 20 +#endif + +#endif // BOOST_MPL_LIMITS_SET_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/unrolling.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/unrolling.hpp new file mode 100644 index 0000000000..773e16aabd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/limits/unrolling.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LIMITS_UNROLLING_HPP_INCLUDED +#define BOOST_MPL_LIMITS_UNROLLING_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/limits/unrolling.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.4 $ + +#if !defined(BOOST_MPL_LIMIT_UNROLLING) +# define BOOST_MPL_LIMIT_UNROLLING 4 +#endif + +#endif // BOOST_MPL_LIMITS_UNROLLING_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/vector.hpp new file mode 100644 index 0000000000..ca79aea8f1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/limits/vector.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED +#define BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/limits/vector.hpp,v $ +// $Date: 2004/09/02 15:40:57 $ +// $Revision: 1.4 $ + +#if !defined(BOOST_MPL_LIMIT_VECTOR_SIZE) +# define BOOST_MPL_LIMIT_VECTOR_SIZE 20 +#endif + +#endif // BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list.hpp b/deal.II/contrib/boost/include/boost/mpl/list.hpp new file mode 100644 index 0000000000..b3f7408669 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_LIST_HPP_INCLUDED +#define BOOST_MPL_LIST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list.hpp,v $ +// $Date: 2004/11/28 01:54:51 $ +// $Revision: 1.9 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_LIST_HEADER \ + BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE).hpp \ + /**/ +#else +# define AUX778076_LIST_HEADER \ + BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_HEADER) +# undef AUX778076_LIST_HEADER +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME list +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_LIST_SIZE +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_LIST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/O1_size.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/O1_size.hpp new file mode 100644 index 0000000000..4040d66583 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/O1_size.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/O1_size.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct O1_size_impl< aux::list_tag > +{ + template< typename List > struct apply + : List::size + { + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/begin_end.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/begin_end.hpp new file mode 100644 index 0000000000..3a60dee7bc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/begin_end.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/begin_end.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct begin_impl< aux::list_tag > +{ + template< typename List > struct apply + { + typedef l_iter type; + }; +}; + +template<> +struct end_impl< aux::list_tag > +{ + template< typename > struct apply + { + typedef l_iter type; + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/clear.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/clear.hpp new file mode 100644 index 0000000000..e5d977245f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/clear.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/clear.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.4 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct clear_impl< aux::list_tag > +{ + template< typename List > struct apply + { + typedef l_end type; + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/empty.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/empty.hpp new file mode 100644 index 0000000000..d2681fcac6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/empty.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/empty.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct empty_impl< aux::list_tag > +{ + template< typename List > struct apply + : not_ + { + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/front.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/front.hpp new file mode 100644 index 0000000000..267063dc58 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/front.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/front.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct front_impl< aux::list_tag > +{ + template< typename List > struct apply + { + typedef typename List::item type; + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/include_preprocessed.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/include_preprocessed.hpp new file mode 100644 index 0000000000..619e182394 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/include_preprocessed.hpp @@ -0,0 +1,27 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/include_preprocessed.hpp,v $ +// $Date: 2004/11/28 01:48:53 $ +// $Revision: 1.4 $ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +#include +#include + +# define AUX778076_HEADER \ + aux_/preprocessed/plain/BOOST_MPL_PREPROCESSED_HEADER \ +/**/ + +# include BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_HEADER) + +# undef AUX778076_HEADER + +#undef BOOST_MPL_PREPROCESSED_HEADER diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/item.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/item.hpp new file mode 100644 index 0000000000..9110efe121 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/item.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/item.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename Size + , typename T + , typename Next + > +struct l_item +{ +// agurt, 17/jul/03: to facilitate the deficient 'is_sequence' implementation +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + typedef int begin; +#endif + typedef aux::list_tag tag; + typedef l_item type; + + typedef Size size; + typedef T item; + typedef Next next; +}; + +struct l_end +{ +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + typedef int begin; +#endif + typedef aux::list_tag tag; + typedef l_end type; + typedef long_<0> size; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/iterator.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/iterator.hpp new file mode 100644 index 0000000000..a51b154648 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/iterator.hpp @@ -0,0 +1,76 @@ + +#ifndef BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/iterator.hpp,v $ +// $Date: 2004/10/01 16:29:37 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename Node > +struct l_iter +{ + typedef aux::l_iter_tag tag; + typedef forward_iterator_tag category; +}; + +template< typename Node > +struct deref< l_iter > +{ + typedef typename Node::item type; +}; + +template< typename Node > +struct next< l_iter > +{ + typedef l_iter< typename Node::next > type; +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template< typename Node > +struct l_iter +{ + typedef aux::l_iter_tag tag; + typedef forward_iterator_tag category; + typedef typename Node::item type; + typedef l_iter< typename mpl::next::type > next; +}; + +#endif + + +template<> struct l_iter +{ + typedef aux::l_iter_tag tag; + typedef forward_iterator_tag category; +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + typedef na type; + typedef l_iter next; +#endif +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, l_iter) + +}} + +#endif // BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/numbered.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/numbered.hpp new file mode 100644 index 0000000000..e9447eadeb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/numbered.hpp @@ -0,0 +1,68 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Peter Dimov 2000-2002 +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/numbered.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.4 $ + +#if defined(BOOST_PP_IS_ITERATING) + +#include +#include +#include +#include + +#define i BOOST_PP_FRAME_ITERATION(1) + +#if i == 1 + +template< + BOOST_PP_ENUM_PARAMS(i, typename T) + > +struct list1 + : l_item< + long_<1> + , T0 + , l_end + > +{ + typedef list1 type; +}; + +#else + +# define MPL_AUX_LIST_TAIL(list, i, T) \ + BOOST_PP_CAT(list,BOOST_PP_DEC(i))< \ + BOOST_PP_ENUM_SHIFTED_PARAMS(i, T) \ + > \ + /**/ + +template< + BOOST_PP_ENUM_PARAMS(i, typename T) + > +struct BOOST_PP_CAT(list,i) + : l_item< + long_ + , T0 + , MPL_AUX_LIST_TAIL(list,i,T) + > +{ + typedef BOOST_PP_CAT(list,i) type; +}; + +# undef MPL_AUX_LIST_TAIL + +#endif // i == 1 + +#undef i + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/numbered_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/numbered_c.hpp new file mode 100644 index 0000000000..7c5329a386 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/numbered_c.hpp @@ -0,0 +1,71 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/numbered_c.hpp,v $ +// $Date: 2004/11/28 01:48:53 $ +// $Revision: 1.5 $ + +#if defined(BOOST_PP_IS_ITERATING) + +#include +#include +#include +#include + +#define i BOOST_PP_FRAME_ITERATION(1) + +#if i == 1 + +template< + typename T + , BOOST_PP_ENUM_PARAMS(i, T C) + > +struct list1_c + : l_item< + long_<1> + , integral_c + , l_end + > +{ + typedef list1_c type; + typedef T value_type; +}; + +#else + +# define MPL_AUX_LIST_C_TAIL(list, i, C) \ + BOOST_PP_CAT(BOOST_PP_CAT(list,BOOST_PP_DEC(i)),_c) \ + /**/ + +template< + typename T + , BOOST_PP_ENUM_PARAMS(i, T C) + > +struct BOOST_PP_CAT(BOOST_PP_CAT(list,i),_c) + : l_item< + long_ + , integral_c + , MPL_AUX_LIST_C_TAIL(list,i,C) + > +{ + typedef BOOST_PP_CAT(BOOST_PP_CAT(list,i),_c) type; + typedef T value_type; +}; + +# undef MPL_AUX_LIST_C_TAIL + +#endif // i == 1 + +#undef i + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/pop_front.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/pop_front.hpp new file mode 100644 index 0000000000..f58471d55e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/pop_front.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/pop_front.hpp,v $ +// $Date: 2004/10/24 08:18:08 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct pop_front_impl< aux::list_tag > +{ + template< typename List > struct apply + { + typedef typename mpl::next::type type; + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list10.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list10.hpp new file mode 100644 index 0000000000..99368d2c18 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list10.hpp @@ -0,0 +1,149 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 + > +struct list1 + : l_item< + long_<1> + , T0 + , l_end + > +{ + typedef list1 type; +}; + +template< + typename T0, typename T1 + > +struct list2 + : l_item< + long_<2> + , T0 + , list1 + > +{ + typedef list2 type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct list3 + : l_item< + long_<3> + , T0 + , list2< T1,T2 > + > +{ + typedef list3 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct list4 + : l_item< + long_<4> + , T0 + , list3< T1,T2,T3 > + > +{ + typedef list4 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct list5 + : l_item< + long_<5> + , T0 + , list4< T1,T2,T3,T4 > + > +{ + typedef list5 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct list6 + : l_item< + long_<6> + , T0 + , list5< T1,T2,T3,T4,T5 > + > +{ + typedef list6 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct list7 + : l_item< + long_<7> + , T0 + , list6< T1,T2,T3,T4,T5,T6 > + > +{ + typedef list7 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct list8 + : l_item< + long_<8> + , T0 + , list7< T1,T2,T3,T4,T5,T6,T7 > + > +{ + typedef list8 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct list9 + : l_item< + long_<9> + , T0 + , list8< T1,T2,T3,T4,T5,T6,T7,T8 > + > +{ + typedef list9 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct list10 + : l_item< + long_<10> + , T0 + , list9< T1,T2,T3,T4,T5,T6,T7,T8,T9 > + > +{ + typedef list10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp new file mode 100644 index 0000000000..7133d71216 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp @@ -0,0 +1,164 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list10_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0 + > +struct list1_c + : l_item< + long_<1> + , integral_c< T,C0 > + , l_end + > +{ + typedef list1_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1 + > +struct list2_c + : l_item< + long_<2> + , integral_c< T,C0 > + , list1_c< T,C1 > + > +{ + typedef list2_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2 + > +struct list3_c + : l_item< + long_<3> + , integral_c< T,C0 > + , list2_c< T,C1,C2 > + > +{ + typedef list3_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3 + > +struct list4_c + : l_item< + long_<4> + , integral_c< T,C0 > + , list3_c< T,C1,C2,C3 > + > +{ + typedef list4_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4 + > +struct list5_c + : l_item< + long_<5> + , integral_c< T,C0 > + , list4_c< T,C1,C2,C3,C4 > + > +{ + typedef list5_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5 + > +struct list6_c + : l_item< + long_<6> + , integral_c< T,C0 > + , list5_c< T,C1,C2,C3,C4,C5 > + > +{ + typedef list6_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6 + > +struct list7_c + : l_item< + long_<7> + , integral_c< T,C0 > + , list6_c< T,C1,C2,C3,C4,C5,C6 > + > +{ + typedef list7_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 + > +struct list8_c + : l_item< + long_<8> + , integral_c< T,C0 > + , list7_c< T,C1,C2,C3,C4,C5,C6,C7 > + > +{ + typedef list8_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 + > +struct list9_c + : l_item< + long_<9> + , integral_c< T,C0 > + , list8_c< T,C1,C2,C3,C4,C5,C6,C7,C8 > + > +{ + typedef list9_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 + > +struct list10_c + : l_item< + long_<10> + , integral_c< T,C0 > + , list9_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9 > + > +{ + typedef list10_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list20.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list20.hpp new file mode 100644 index 0000000000..750e495f3f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list20.hpp @@ -0,0 +1,169 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct list11 + : l_item< + long_<11> + , T0 + , list10< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > + > +{ + typedef list11 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct list12 + : l_item< + long_<12> + , T0 + , list11< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > + > +{ + typedef list12 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct list13 + : l_item< + long_<13> + , T0 + , list12< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > + > +{ + typedef list13 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct list14 + : l_item< + long_<14> + , T0 + , list13< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > + > +{ + typedef list14 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct list15 + : l_item< + long_<15> + , T0 + , list14< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 > + > +{ + typedef list15 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct list16 + : l_item< + long_<16> + , T0 + , list15< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 > + > +{ + typedef list16 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct list17 + : l_item< + long_<17> + , T0 + , list16< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 > + > +{ + typedef list17 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct list18 + : l_item< + long_<18> + , T0 + , list17< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 > + > +{ + typedef list18 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct list19 + : l_item< + long_<19> + , T0 + , list18< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 > + > +{ + typedef list19 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct list20 + : l_item< + long_<20> + , T0 + , list19< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 > + > +{ + typedef list20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp new file mode 100644 index 0000000000..7f15acf3e9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp @@ -0,0 +1,173 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list20_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + > +struct list11_c + : l_item< + long_<11> + , integral_c< T,C0 > + , list10_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > + > +{ + typedef list11_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11 + > +struct list12_c + : l_item< + long_<12> + , integral_c< T,C0 > + , list11_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > + > +{ + typedef list12_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12 + > +struct list13_c + : l_item< + long_<13> + , integral_c< T,C0 > + , list12_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > + > +{ + typedef list13_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13 + > +struct list14_c + : l_item< + long_<14> + , integral_c< T,C0 > + , list13_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 > + > +{ + typedef list14_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14 + > +struct list15_c + : l_item< + long_<15> + , integral_c< T,C0 > + , list14_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 > + > +{ + typedef list15_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15 + > +struct list16_c + : l_item< + long_<16> + , integral_c< T,C0 > + , list15_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 > + > +{ + typedef list16_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16 + > +struct list17_c + : l_item< + long_<17> + , integral_c< T,C0 > + , list16_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 > + > +{ + typedef list17_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17 + > +struct list18_c + : l_item< + long_<18> + , integral_c< T,C0 > + , list17_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 > + > +{ + typedef list18_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 + > +struct list19_c + : l_item< + long_<19> + , integral_c< T,C0 > + , list18_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 > + > +{ + typedef list19_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 + > +struct list20_c + : l_item< + long_<20> + , integral_c< T,C0 > + , list19_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 > + > +{ + typedef list20_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list30.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list30.hpp new file mode 100644 index 0000000000..5459101196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list30.hpp @@ -0,0 +1,189 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20 + > +struct list21 + : l_item< + long_<21> + , T0 + , list20< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 > + > +{ + typedef list21 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21 + > +struct list22 + : l_item< + long_<22> + , T0 + , list21< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 > + > +{ + typedef list22 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22 + > +struct list23 + : l_item< + long_<23> + , T0 + , list22< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 > + > +{ + typedef list23 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23 + > +struct list24 + : l_item< + long_<24> + , T0 + , list23< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 > + > +{ + typedef list24 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + > +struct list25 + : l_item< + long_<25> + , T0 + , list24< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 > + > +{ + typedef list25 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25 + > +struct list26 + : l_item< + long_<26> + , T0 + , list25< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 > + > +{ + typedef list26 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26 + > +struct list27 + : l_item< + long_<27> + , T0 + , list26< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 > + > +{ + typedef list27 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27 + > +struct list28 + : l_item< + long_<28> + , T0 + , list27< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 > + > +{ + typedef list28 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28 + > +struct list29 + : l_item< + long_<29> + , T0 + , list28< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 > + > +{ + typedef list29 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + > +struct list30 + : l_item< + long_<30> + , T0 + , list29< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29 > + > +{ + typedef list30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp new file mode 100644 index 0000000000..5393d792bd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp @@ -0,0 +1,183 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list30_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + > +struct list21_c + : l_item< + long_<21> + , integral_c< T,C0 > + , list20_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 > + > +{ + typedef list21_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21 + > +struct list22_c + : l_item< + long_<22> + , integral_c< T,C0 > + , list21_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 > + > +{ + typedef list22_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22 + > +struct list23_c + : l_item< + long_<23> + , integral_c< T,C0 > + , list22_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 > + > +{ + typedef list23_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23 + > +struct list24_c + : l_item< + long_<24> + , integral_c< T,C0 > + , list23_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 > + > +{ + typedef list24_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24 + > +struct list25_c + : l_item< + long_<25> + , integral_c< T,C0 > + , list24_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 > + > +{ + typedef list25_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25 + > +struct list26_c + : l_item< + long_<26> + , integral_c< T,C0 > + , list25_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 > + > +{ + typedef list26_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26 + > +struct list27_c + : l_item< + long_<27> + , integral_c< T,C0 > + , list26_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 > + > +{ + typedef list27_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27 + > +struct list28_c + : l_item< + long_<28> + , integral_c< T,C0 > + , list27_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 > + > +{ + typedef list28_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 + > +struct list29_c + : l_item< + long_<29> + , integral_c< T,C0 > + , list28_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 > + > +{ + typedef list29_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 + > +struct list30_c + : l_item< + long_<30> + , integral_c< T,C0 > + , list29_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29 > + > +{ + typedef list30_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list40.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list40.hpp new file mode 100644 index 0000000000..68c6761364 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list40.hpp @@ -0,0 +1,209 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30 + > +struct list31 + : l_item< + long_<31> + , T0 + , list30< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30 > + > +{ + typedef list31 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31 + > +struct list32 + : l_item< + long_<32> + , T0 + , list31< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31 > + > +{ + typedef list32 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32 + > +struct list33 + : l_item< + long_<33> + , T0 + , list32< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32 > + > +{ + typedef list33 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33 + > +struct list34 + : l_item< + long_<34> + , T0 + , list33< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33 > + > +{ + typedef list34 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + > +struct list35 + : l_item< + long_<35> + , T0 + , list34< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34 > + > +{ + typedef list35 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35 + > +struct list36 + : l_item< + long_<36> + , T0 + , list35< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35 > + > +{ + typedef list36 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36 + > +struct list37 + : l_item< + long_<37> + , T0 + , list36< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36 > + > +{ + typedef list37 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37 + > +struct list38 + : l_item< + long_<38> + , T0 + , list37< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37 > + > +{ + typedef list38 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38 + > +struct list39 + : l_item< + long_<39> + , T0 + , list38< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38 > + > +{ + typedef list39 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + > +struct list40 + : l_item< + long_<40> + , T0 + , list39< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39 > + > +{ + typedef list40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp new file mode 100644 index 0000000000..0c51ba2095 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp @@ -0,0 +1,193 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list40_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + > +struct list31_c + : l_item< + long_<31> + , integral_c< T,C0 > + , list30_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30 > + > +{ + typedef list31_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31 + > +struct list32_c + : l_item< + long_<32> + , integral_c< T,C0 > + , list31_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31 > + > +{ + typedef list32_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32 + > +struct list33_c + : l_item< + long_<33> + , integral_c< T,C0 > + , list32_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32 > + > +{ + typedef list33_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33 + > +struct list34_c + : l_item< + long_<34> + , integral_c< T,C0 > + , list33_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33 > + > +{ + typedef list34_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34 + > +struct list35_c + : l_item< + long_<35> + , integral_c< T,C0 > + , list34_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34 > + > +{ + typedef list35_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35 + > +struct list36_c + : l_item< + long_<36> + , integral_c< T,C0 > + , list35_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35 > + > +{ + typedef list36_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36 + > +struct list37_c + : l_item< + long_<37> + , integral_c< T,C0 > + , list36_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36 > + > +{ + typedef list37_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37 + > +struct list38_c + : l_item< + long_<38> + , integral_c< T,C0 > + , list37_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37 > + > +{ + typedef list38_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 + > +struct list39_c + : l_item< + long_<39> + , integral_c< T,C0 > + , list38_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38 > + > +{ + typedef list39_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 + > +struct list40_c + : l_item< + long_<40> + , integral_c< T,C0 > + , list39_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39 > + > +{ + typedef list40_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list50.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list50.hpp new file mode 100644 index 0000000000..4cc22da278 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list50.hpp @@ -0,0 +1,229 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40 + > +struct list41 + : l_item< + long_<41> + , T0 + , list40< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40 > + > +{ + typedef list41 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41 + > +struct list42 + : l_item< + long_<42> + , T0 + , list41< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41 > + > +{ + typedef list42 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42 + > +struct list43 + : l_item< + long_<43> + , T0 + , list42< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42 > + > +{ + typedef list43 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43 + > +struct list44 + : l_item< + long_<44> + , T0 + , list43< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43 > + > +{ + typedef list44 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + > +struct list45 + : l_item< + long_<45> + , T0 + , list44< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44 > + > +{ + typedef list45 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45 + > +struct list46 + : l_item< + long_<46> + , T0 + , list45< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45 > + > +{ + typedef list46 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46 + > +struct list47 + : l_item< + long_<47> + , T0 + , list46< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46 > + > +{ + typedef list47 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47 + > +struct list48 + : l_item< + long_<48> + , T0 + , list47< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47 > + > +{ + typedef list48 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48 + > +struct list49 + : l_item< + long_<49> + , T0 + , list48< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48 > + > +{ + typedef list49 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48, typename T49 + > +struct list50 + : l_item< + long_<50> + , T0 + , list49< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48,T49 > + > +{ + typedef list50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp new file mode 100644 index 0000000000..28c061d5bf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp @@ -0,0 +1,203 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/list/list50_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + > +struct list41_c + : l_item< + long_<41> + , integral_c< T,C0 > + , list40_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40 > + > +{ + typedef list41_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41 + > +struct list42_c + : l_item< + long_<42> + , integral_c< T,C0 > + , list41_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41 > + > +{ + typedef list42_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42 + > +struct list43_c + : l_item< + long_<43> + , integral_c< T,C0 > + , list42_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42 > + > +{ + typedef list43_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43 + > +struct list44_c + : l_item< + long_<44> + , integral_c< T,C0 > + , list43_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43 > + > +{ + typedef list44_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44 + > +struct list45_c + : l_item< + long_<45> + , integral_c< T,C0 > + , list44_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44 > + > +{ + typedef list45_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45 + > +struct list46_c + : l_item< + long_<46> + , integral_c< T,C0 > + , list45_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45 > + > +{ + typedef list46_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46 + > +struct list47_c + : l_item< + long_<47> + , integral_c< T,C0 > + , list46_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46 > + > +{ + typedef list47_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47 + > +struct list48_c + : l_item< + long_<48> + , integral_c< T,C0 > + , list47_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47 > + > +{ + typedef list48_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 + > +struct list49_c + : l_item< + long_<49> + , integral_c< T,C0 > + , list48_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48 > + > +{ + typedef list49_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 + > +struct list50_c + : l_item< + long_<50> + , integral_c< T,C0 > + , list49_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48,C49 > + > +{ + typedef list50_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/push_back.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/push_back.hpp new file mode 100644 index 0000000000..38ae8ec6ee --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/push_back.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/push_back.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Tag > struct has_push_back_impl; + +template<> +struct has_push_back_impl< aux::list_tag > +{ + template< typename Seq > struct apply + : false_ + { + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/push_front.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/push_front.hpp new file mode 100644 index 0000000000..deb6bb327b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/push_front.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/push_front.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct push_front_impl< aux::list_tag > +{ + template< typename List, typename T > struct apply + { + typedef l_item< + typename next::type + , T + , typename List::type + > type; + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/size.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/size.hpp new file mode 100644 index 0000000000..f390ed7c28 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/size.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/size.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct size_impl< aux::list_tag > +{ + template< typename List > struct apply + : List::size + { + }; +}; + +}} + +#endif // BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/aux_/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/list/aux_/tag.hpp new file mode 100644 index 0000000000..c484f37470 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/aux_/tag.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/aux_/tag.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { namespace aux { + +struct list_tag; +struct l_iter_tag; + +}}} + +#endif // BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list0.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list0.hpp new file mode 100644 index 0000000000..b2d41f4322 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list0.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_LIST_LIST0_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list0.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Dummy = na > struct list0; + +template<> struct list0 + : l_end +{ + typedef l_end type; +}; + +}} + +#endif // BOOST_MPL_LIST_LIST0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list0_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list0_c.hpp new file mode 100644 index 0000000000..43f8ad8340 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list0_c.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_LIST_LIST0_C_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST0_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list0_c.hpp,v $ +// $Date: 2004/11/28 07:18:24 $ +// $Revision: 1.5 $ + +#include +#include + +namespace boost { namespace mpl { + +template< typename T > struct list0_c + : l_end +{ + typedef l_end type; + typedef T value_type; +}; + +}} + +#endif // BOOST_MPL_LIST_LIST0_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list10.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list10.hpp new file mode 100644 index 0000000000..6b1de483c5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list10.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST10_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST10_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list10.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list10.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST10_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list10_c.hpp new file mode 100644 index 0000000000..af77809466 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list10_c.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST10_C_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST10_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list10_c.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list10_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST10_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list20.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list20.hpp new file mode 100644 index 0000000000..71fe5f4290 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list20.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST20_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST20_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list20.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list20.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST20_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list20_c.hpp new file mode 100644 index 0000000000..14112eb894 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list20_c.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST20_C_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST20_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list20_c.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list20_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST20_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list30.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list30.hpp new file mode 100644 index 0000000000..6b7324c53b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list30.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST30_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST30_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list30.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list30.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST30_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list30_c.hpp new file mode 100644 index 0000000000..c0b6a99f0c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list30_c.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST30_C_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST30_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list30_c.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list30_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST30_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list40.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list40.hpp new file mode 100644 index 0000000000..0f807cd4f1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list40.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST40_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST40_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list40.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list40.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST40_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list40_c.hpp new file mode 100644 index 0000000000..07f26822ed --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list40_c.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST40_C_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST40_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list40_c.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list40_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST40_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list50.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list50.hpp new file mode 100644 index 0000000000..9c95c48458 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list50.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST50_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST50_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list50.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list50.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST50_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list/list50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list/list50_c.hpp new file mode 100644 index 0000000000..a25bc470f3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list/list50_c.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_LIST_LIST50_C_HPP_INCLUDED +#define BOOST_MPL_LIST_LIST50_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list/list50_c.hpp,v $ +// $Date: 2004/09/02 15:40:58 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list50_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_LIST_LIST50_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/list_c.hpp b/deal.II/contrib/boost/include/boost/mpl/list_c.hpp new file mode 100644 index 0000000000..e33fa584a6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/list_c.hpp @@ -0,0 +1,60 @@ + +#ifndef BOOST_MPL_LIST_C_HPP_INCLUDED +#define BOOST_MPL_LIST_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/list_c.hpp,v $ +// $Date: 2004/11/28 01:54:51 $ +// $Revision: 1.8 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_LIST_C_HEADER \ + BOOST_PP_CAT(BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE),_c).hpp \ + /**/ +#else +# define AUX778076_LIST_C_HEADER \ + BOOST_PP_CAT(BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE),_c)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_C_HEADER) +# undef AUX778076_LIST_C_HEADER +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER list_c.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME list_c +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_LIST_SIZE +# define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(list,n),_c) +# define AUX778076_SEQUENCE_INTEGRAL_WRAPPER +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_LIST_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/logical.hpp b/deal.II/contrib/boost/include/boost/mpl/logical.hpp new file mode 100644 index 0000000000..391d9e0e9b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/logical.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LOGICAL_HPP_INCLUDED +#define BOOST_MPL_LOGICAL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/logical.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.5 $ + +#include +#include +#include + +#endif // BOOST_MPL_LOGICAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/long.hpp b/deal.II/contrib/boost/include/boost/mpl/long.hpp new file mode 100644 index 0000000000..e6f16c8b92 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/long.hpp @@ -0,0 +1,22 @@ + +#ifndef BOOST_MPL_LONG_HPP_INCLUDED +#define BOOST_MPL_LONG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/long.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.4 $ + +#include + +#define AUX_WRAPPER_VALUE_TYPE long +#include + +#endif // BOOST_MPL_LONG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/long_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/long_fwd.hpp new file mode 100644 index 0000000000..7c0df6d724 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/long_fwd.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_LONG_FWD_HPP_INCLUDED +#define BOOST_MPL_LONG_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/long_fwd.hpp,v $ +// $Date: 2004/09/28 13:56:58 $ +// $Revision: 1.4 $ + +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct long_; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(long_) + +#endif // BOOST_MPL_LONG_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/lower_bound.hpp b/deal.II/contrib/boost/include/boost/mpl/lower_bound.hpp new file mode 100644 index 0000000000..6d59c0a83c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/lower_bound.hpp @@ -0,0 +1,143 @@ + +#ifndef BOOST_MPL_LOWER_BOUND_HPP_INCLUDED +#define BOOST_MPL_LOWER_BOUND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/lower_bound.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include + +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +# define BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL +#endif + +#if !defined(BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +#else +# include +# include +# include +#endif + +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL) + +// agurt 23/oct/02: has a wrong complexity etc., but at least it works +// feel free to contribute a better implementation! +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + , typename Predicate = less<> + , typename pred_ = typename lambda::type + > +struct lower_bound + : find_if< Sequence, bind1< not_<>, bind2 > > +{ +}; + +#else + +namespace aux { + +template< + typename Distance + , typename Predicate + , typename T + , typename DeferredIterator + > +struct lower_bound_step_impl; + +template< + typename Distance + , typename Predicate + , typename T + , typename DeferredIterator + > +struct lower_bound_step +{ + typedef typename eval_if< + Distance + , lower_bound_step_impl + , DeferredIterator + >::type type; +}; + +template< + typename Distance + , typename Predicate + , typename T + , typename DeferredIterator + > +struct lower_bound_step_impl +{ + typedef typename divides< Distance, long_<2> >::type offset_; + typedef typename DeferredIterator::type iter_; + typedef typename advance< iter_,offset_ >::type middle_; + typedef typename apply2< + Predicate + , typename deref::type + , T + >::type cond_; + + typedef typename prior< minus< Distance, offset_> >::type step_; + typedef lower_bound_step< offset_,Predicate,T,DeferredIterator > step_forward_; + typedef lower_bound_step< step_,Predicate,T,next > step_backward_; + typedef typename eval_if< + cond_ + , step_backward_ + , step_forward_ + >::type type; +}; + + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + , typename Predicate = less<> + > +struct lower_bound +{ + private: + typedef typename lambda::type pred_; + typedef typename size::type size_; + + public: + typedef typename aux::lower_bound_step< + size_,pred_,T,begin + >::type type; +}; + +#endif // BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL + +BOOST_MPL_AUX_NA_SPEC(2, lower_bound) + +}} + +#endif // BOOST_MPL_LOWER_BOUND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map.hpp b/deal.II/contrib/boost/include/boost/mpl/map.hpp new file mode 100644 index 0000000000..af6c839857 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_MAP_HPP_INCLUDED +#define BOOST_MPL_MAP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_MAP_HEADER \ + BOOST_PP_CAT(map, BOOST_MPL_LIMIT_MAP_SIZE).hpp \ + /**/ +#else +# define AUX778076_MAP_HEADER \ + BOOST_PP_CAT(map, BOOST_MPL_LIMIT_MAP_SIZE)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/map/AUX778076_MAP_HEADER) +# undef AUX778076_MAP_HEADER +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER map.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME map +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_MAP_SIZE +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_MAP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/at_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/at_impl.hpp new file mode 100644 index 0000000000..28a761aa6a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/at_impl.hpp @@ -0,0 +1,144 @@ + +#ifndef BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/at_impl.hpp,v $ +// $Date: 2004/12/14 14:05:31 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) +# include +# include +# include +# include +#endif + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template< typename Map, typename Key > +struct m_at +{ + typedef aux::type_wrapper key_; + typedef __typeof__( BOOST_MPL_AUX_OVERLOAD_CALL_VALUE_BY_KEY( + Map + , BOOST_MPL_AUX_STATIC_CAST(key_*, 0) + ) ) type; +}; + +template<> +struct at_impl< aux::map_tag > +{ + template< typename Map, typename Key > struct apply + : aux::wrapped_type< typename m_at< + Map + , Key + >::type > + { + }; +}; + +// agurt 31/jan/04: two-step implementation for the sake of GCC 3.x +template< typename Map, long order > +struct item_by_order_impl +{ + typedef __typeof__( BOOST_MPL_AUX_OVERLOAD_CALL_ITEM_BY_ORDER( + Map + , BOOST_MPL_AUX_STATIC_CAST(long_*, 0) + ) ) type; +}; + +template< typename Map, long order > +struct item_by_order + : aux::wrapped_type< + typename item_by_order_impl::type + > +{ +}; + +#else // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename Map, long n > struct m_at +{ + typedef void_ type; +}; + +# else + +template< long n > struct m_at_impl +{ + template< typename Map > struct result_ + { + typedef void_ type; + }; +}; + +template< typename Map, long n > struct m_at +{ + typedef typename m_at_impl::result_::type type; +}; + +# endif + + +template<> +struct at_impl< aux::map_tag > +{ + template< typename Map, typename Key > struct apply + { + typedef typename m_at< Map, (x_order_impl::value - 2) >::type item_; + typedef typename eval_if< + is_void_ + , void_ + , second + >::type type; + }; +}; + +template< typename Map, long order > struct is_item_masked +{ + BOOST_STATIC_CONSTANT(bool, value = + sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED( + Map + , BOOST_MPL_AUX_STATIC_CAST(long_*, 0) + ) ) == sizeof(aux::yes_tag) + ); +}; + +template< typename Map, long order > struct item_by_order +{ + typedef typename eval_if_c< + is_item_masked::value + , void_ + , m_at + >::type type; +}; + +#endif + +}} + +#endif // BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/begin_end_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/begin_end_impl.hpp new file mode 100644 index 0000000000..76f7616dce --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/begin_end_impl.hpp @@ -0,0 +1,50 @@ + +#ifndef BOOST_MPL_MAP_AUX_BEGIN_END_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_BEGIN_END_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/begin_end_impl.hpp,v $ +// $Date: 2004/09/05 09:42:58 $ +// $Revision: 1.3 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct begin_impl< aux::map_tag > +{ + template< typename Map > struct apply + { + typedef typename next< typename Map::order >::type max_order_; + typedef m_iter< + Map + , next_order::value + , max_order_::value + > type; + }; +}; + +template<> +struct end_impl< aux::map_tag > +{ + template< typename Map > struct apply + { + typedef typename next< typename Map::order >::type max_order_; + typedef m_iter< Map,max_order_::value,max_order_::value > type; + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_BEGIN_END_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/clear_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/clear_impl.hpp new file mode 100644 index 0000000000..40faddfc41 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/clear_impl.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_MAP_AUX_CLEAR_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_CLEAR_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/clear_impl.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct clear_impl< aux::map_tag > +{ + template< typename Map > struct apply + { + typedef map0<> type; + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_CLEAR_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/contains_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/contains_impl.hpp new file mode 100644 index 0000000000..67a48c7bab --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/contains_impl.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_MAP_AUX_CONTAINS_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_CONTAINS_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/contains_impl.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +template<> +struct contains_impl< aux::map_tag > +{ + template< typename Map, typename Pair > struct apply + : is_same< + typename at_impl::apply< + Map + , typename Pair::first + >::type + , typename Pair::second + > + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_CONTAINS_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/empty_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/empty_impl.hpp new file mode 100644 index 0000000000..35bee0c275 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/empty_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_MAP_AUX_EMPTY_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_EMPTY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/empty_impl.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct empty_impl< aux::map_tag > +{ + template< typename Map > struct apply + : not_< typename Map::size > + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_EMPTY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/erase_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/erase_impl.hpp new file mode 100644 index 0000000000..d8c1d83d8b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/erase_impl.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_MAP_AUX_ERASE_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_ERASE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/erase_impl.hpp,v $ +// $Date: 2004/09/05 09:42:58 $ +// $Revision: 1.3 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct erase_impl< aux::map_tag > +{ + template< + typename Map + , typename Pos + , typename unused_ + > + struct apply + : erase_key_impl + ::apply + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_ERASE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/erase_key_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/erase_key_impl.hpp new file mode 100644 index 0000000000..98bb2a1eb0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/erase_key_impl.hpp @@ -0,0 +1,53 @@ + +#ifndef BOOST_MPL_MAP_AUX_ERASE_KEY_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_ERASE_KEY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/erase_key_impl.hpp,v $ +// $Date: 2004/09/05 09:42:58 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +template<> +struct erase_key_impl< aux::map_tag > +{ + template< + typename Map + , typename Key + > + struct apply + : eval_if< + has_key_impl::apply + , eval_if< + is_same< Key,typename Map::key_ > + , base + , identity< m_mask > + > + , identity + > + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_ERASE_KEY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/has_key_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/has_key_impl.hpp new file mode 100644 index 0000000000..3a529f0e05 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/has_key_impl.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_MAP_AUX_HAS_KEY_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_HAS_KEY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/has_key_impl.hpp,v $ +// $Date: 2004/09/05 09:42:58 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct has_key_impl< aux::map_tag > +{ + template< typename Map, typename Key > struct apply +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + : is_not_void_< + typename at_impl + ::apply::type + > +#else + : bool_< ( x_order_impl::value > 1 ) > +#endif + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_HAS_KEY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/include_preprocessed.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/include_preprocessed.hpp new file mode 100644 index 0000000000..e1270b121d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/include_preprocessed.hpp @@ -0,0 +1,47 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/include_preprocessed.hpp,v $ +// $Date: 2004/09/05 09:42:58 $ +// $Revision: 1.3 $ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +#include +#include +#include + +#include +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) +# define AUX778076_INCLUDE_DIR typeof_based +#elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# define AUX778076_INCLUDE_DIR no_ctps +#else +# define AUX778076_INCLUDE_DIR plain +#endif + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_HEADER \ + AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#else +# define AUX778076_HEADER \ + BOOST_PP_CAT(AUX778076_INCLUDE_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#endif + + +# include BOOST_PP_STRINGIZE(boost/mpl/map/aux_/preprocessed/AUX778076_HEADER) + +# undef AUX778076_HEADER +# undef AUX778076_INCLUDE_DIR + +#undef BOOST_MPL_PREPROCESSED_HEADER diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/insert_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/insert_impl.hpp new file mode 100644 index 0000000000..86b60109d2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/insert_impl.hpp @@ -0,0 +1,72 @@ + +#ifndef BOOST_MPL_MAP_AUX_INSERT_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_INSERT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/insert_impl.hpp,v $ +// $Date: 2004/12/14 14:05:31 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { +template< typename Map, typename Pair > +struct map_insert_impl + : if_< + contains_impl::apply + , Map +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + , m_item< + typename Pair::first + , typename Pair::second + , Map + > +#else + , m_item< + next< typename Map::size >::type::value + , typename Pair::first + , typename Pair::second + , Map + > +#endif + > +{ +}; +} + +template<> +struct insert_impl< aux::map_tag > +{ + template< + typename Map + , typename PosOrKey + , typename KeyOrNA + > + struct apply + : aux::map_insert_impl< + Map + , typename if_na::type + > + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_INSERT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/item.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/item.hpp new file mode 100644 index 0000000000..516ebeab12 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/item.hpp @@ -0,0 +1,138 @@ + +#ifndef BOOST_MPL_MAP_AUX_ITEM_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_ITEM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/item.hpp,v $ +// $Date: 2004/12/14 14:05:32 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template< typename Key, typename T, typename Base > +struct m_item + : Base +{ + typedef Key key_; + typedef pair item; + typedef Base base; + + typedef typename next< typename Base::size >::type size; + typedef typename next< typename Base::order >::type order; + +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + typedef typename aux::weighted_tag::type order_tag_; +#else + typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value]; +#endif + + BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, VALUE_BY_KEY, m_item, aux::type_wrapper* ); + BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, ITEM_BY_ORDER, m_item, order* ); + BOOST_MPL_AUX_MAP_OVERLOAD( order_tag_, ORDER_BY_KEY, m_item, aux::type_wrapper* ); +}; + + +template< typename Key, typename Base > +struct m_mask + : Base +{ + typedef void_ key_; + typedef Base base; + + typedef typename prior< typename Base::size >::type size; + typedef typename x_order_impl::type key_order_; + + BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, VALUE_BY_KEY, m_mask, aux::type_wrapper* ); + BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, ITEM_BY_ORDER, m_mask, key_order_* ); +}; + +#else // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< long n, typename Key, typename T, typename Base > +struct m_item; + +# else + +template< long n > +struct m_item_impl +{ + template< typename Key, typename T, typename Base > + struct result_; +}; + +template< long n, typename Key, typename T, typename Base > +struct m_item + : m_item_impl::result_ +{ +}; + + +# endif + + +template< typename Key, typename T, typename Base > +struct m_item_ + : Base +{ + typedef Key key_; + typedef Base base; + typedef m_item_ type; + + typedef typename next< typename Base::size >::type size; + typedef typename next< typename Base::order >::type order; + +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + typedef typename aux::weighted_tag::type order_tag_; +#else + typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value]; +#endif + + BOOST_MPL_AUX_MAP_OVERLOAD( order_tag_, ORDER_BY_KEY, m_item_, aux::type_wrapper* ); +}; + +template< typename Key, typename Base > +struct m_mask + : Base +{ + typedef void_ key_; + typedef Base base; + + typedef typename prior< typename Base::size >::type size; + typedef typename x_order_impl::type key_order_; + + BOOST_MPL_AUX_MAP_OVERLOAD( aux::no_tag, ORDER_BY_KEY, m_mask, aux::type_wrapper* ); + BOOST_MPL_AUX_MAP_OVERLOAD( aux::yes_tag, IS_MASKED, m_mask, key_order_* ); +}; + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_MAP_AUX_ITEM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/iterator.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/iterator.hpp new file mode 100644 index 0000000000..85fe3a52a0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/iterator.hpp @@ -0,0 +1,169 @@ + +#ifndef BOOST_MPL_MAP_AUX_ITERATOR_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_ITERATOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/iterator.hpp,v $ +// $Date: 2004/12/14 14:05:32 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename Map + , long order + , long max_order + > +struct next_order + : if_< + is_void_< typename item_by_order::type > + , next_order + , long_ + >::type +{ +}; + +template< + typename Map + , long max_order + > +struct next_order + : long_ +{ +}; + + +template< typename Map, long order, long max_order > +struct m_iter +{ + typedef forward_iterator_tag category; + typedef typename item_by_order::type type; +}; + +template< typename Map, long max_order > +struct m_iter +{ + typedef forward_iterator_tag category; +}; + + +template< typename Map, long order, long max_order > +struct next< m_iter > +{ + typedef m_iter< + Map + , next_order::value + , max_order + > type; +}; + +template< typename Map, long max_order > +struct next< m_iter > +{ +}; + +#else + +template< + typename Map + , BOOST_MPL_AUX_NTTP_DECL(long, order) + , BOOST_MPL_AUX_NTTP_DECL(long, max_order) + > +struct next_order; + +template< + typename Map + , BOOST_MPL_AUX_NTTP_DECL(long, order) + , BOOST_MPL_AUX_NTTP_DECL(long, max_order) + > +struct next_order_impl + : if_< + is_void_< typename item_by_order::type > + , next_order + , long_ + >::type + { + }; + +template< + typename Map + , BOOST_MPL_AUX_NTTP_DECL(long, order) + , BOOST_MPL_AUX_NTTP_DECL(long, max_order) + > +struct next_order + : if_c< + (order != max_order) + , next_order_impl + , long_ + >::type +{ +}; + + +template< + typename Map + , BOOST_MPL_AUX_NTTP_DECL(long, order) + , BOOST_MPL_AUX_NTTP_DECL(long, max_order) + > +struct m_iter; + +struct m_iter_empty_base {}; + +template< + typename Map + , BOOST_MPL_AUX_NTTP_DECL(long, order) + , BOOST_MPL_AUX_NTTP_DECL(long, max_order) + > +struct m_iter_base +{ + typedef typename item_by_order::type type; + + typedef m_iter< + Map + , next_order::value + , max_order + > next; +}; + +template< + typename Map + , BOOST_MPL_AUX_NTTP_DECL(long, order) + , BOOST_MPL_AUX_NTTP_DECL(long, max_order) + > +struct m_iter + : if_c< + (order == max_order) + , m_iter_empty_base + , m_iter_base + >::type +{ + typedef forward_iterator_tag category; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +}} + +#endif // BOOST_MPL_MAP_AUX_ITERATOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/key_type_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/key_type_impl.hpp new file mode 100644 index 0000000000..0a50415e31 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/key_type_impl.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_MAP_AUX_KEY_TYPE_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_KEY_TYPE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/key_type_impl.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { +namespace mpl { + +template<> +struct key_type_impl< aux::map_tag > +{ + template< typename Map, typename T > struct apply + : first + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_KEY_TYPE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/map0.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/map0.hpp new file mode 100644 index 0000000000..e4a52f6c47 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/map0.hpp @@ -0,0 +1,74 @@ + +#ifndef BOOST_MPL_MAP_AUX_MAP0_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_MAP0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/map0.hpp,v $ +// $Date: 2004/10/13 18:23:36 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) + +# define BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T) \ + friend R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ +/**/ + +# define BOOST_MPL_AUX_MAP_OVERLOAD(R, f, X, T) \ + BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T) \ +/**/ + +#else + +# define BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T) \ + static R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ +/**/ + +# define BOOST_MPL_AUX_MAP_OVERLOAD(R, f, X, T) \ + BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T); \ + using Base::BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f) \ +/**/ + +#endif + + +template< typename Dummy = na > struct map0 +{ + typedef map0 type; + typedef aux::map_tag tag; + typedef void_ key_; + typedef long_<1> order; + typedef long_<0> size; + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + BOOST_MPL_AUX_MAP0_OVERLOAD( aux::type_wrapper, VALUE_BY_KEY, map0<>, void const volatile* ); + BOOST_MPL_AUX_MAP0_OVERLOAD( aux::type_wrapper, ITEM_BY_ORDER, map0<>, long_<1>* ); + BOOST_MPL_AUX_MAP0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, map0<>, void const volatile* ); +#else + BOOST_MPL_AUX_MAP0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, map0<>, void const volatile* ); + BOOST_MPL_AUX_MAP0_OVERLOAD( aux::no_tag, IS_MASKED, map0<>, void const volatile* ); +#endif +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_MAP0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/numbered.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/numbered.hpp new file mode 100644 index 0000000000..8dd0dd0f0f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/numbered.hpp @@ -0,0 +1,110 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if !defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/numbered.hpp,v $ +// $Date: 2004/12/14 14:05:32 $ +// $Revision: 1.4 $ + +#else + +#include +#include +#include +#include +#include + +#define i_ BOOST_PP_FRAME_ITERATION(1) + +# define AUX778076_MAP_TAIL(map, i_, P) \ + BOOST_PP_CAT(map,i_)< \ + BOOST_PP_ENUM_PARAMS(i_, P) \ + > \ + /**/ + + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template< + BOOST_PP_ENUM_PARAMS(i_, typename P) + > +struct BOOST_PP_CAT(map,i_) + : m_item< + typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::first + , typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::second + , AUX778076_MAP_TAIL(map,BOOST_PP_DEC(i_),P) + > +{ + typedef BOOST_PP_CAT(map,i_) type; +}; + +#else // "brute force" implementation + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename Map> +struct m_at +{ + typedef typename Map::BOOST_PP_CAT(item,BOOST_PP_DEC(i_)) type; +}; + +template< typename Key, typename T, typename Base > +struct m_item + : m_item_ +{ + typedef pair BOOST_PP_CAT(item,BOOST_PP_DEC(i_)); +}; + +# else + +template<> +struct m_at_impl +{ + template< typename Map > struct result_ + { + typedef typename Map::BOOST_PP_CAT(item,BOOST_PP_DEC(i_)) type; + }; +}; + +template<> +struct m_item_impl +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_ + { + typedef pair BOOST_PP_CAT(item,BOOST_PP_DEC(i_)); + }; +}; + +# endif + +template< + BOOST_PP_ENUM_PARAMS(i_, typename P) + > +struct BOOST_PP_CAT(map,i_) + : m_item< + i_ + , typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::first + , typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::second + , AUX778076_MAP_TAIL(map,BOOST_PP_DEC(i_),P) + > +{ + typedef BOOST_PP_CAT(map,i_) type; +}; + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +# undef AUX778076_MAP_TAIL + +#undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp new file mode 100644 index 0000000000..626c456361 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp @@ -0,0 +1,350 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template<> +struct m_at_impl<0> +{ + template< typename Map > struct result_ + { + typedef typename Map::item0 type; + }; +}; + +template<> +struct m_item_impl<1> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item0; + }; +}; + +template< + typename P0 + > +struct map1 + : m_item< + 1 + , typename P0::first + , typename P0::second + , map0< > + > +{ + typedef map1 type; +}; + +template<> +struct m_at_impl<1> +{ + template< typename Map > struct result_ + { + typedef typename Map::item1 type; + }; +}; + +template<> +struct m_item_impl<2> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item1; + }; +}; + +template< + typename P0, typename P1 + > +struct map2 + : m_item< + 2 + , typename P1::first + , typename P1::second + , map1 + > +{ + typedef map2 type; +}; + +template<> +struct m_at_impl<2> +{ + template< typename Map > struct result_ + { + typedef typename Map::item2 type; + }; +}; + +template<> +struct m_item_impl<3> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item2; + }; +}; + +template< + typename P0, typename P1, typename P2 + > +struct map3 + : m_item< + 3 + , typename P2::first + , typename P2::second + , map2< P0,P1 > + > +{ + typedef map3 type; +}; + +template<> +struct m_at_impl<3> +{ + template< typename Map > struct result_ + { + typedef typename Map::item3 type; + }; +}; + +template<> +struct m_item_impl<4> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item3; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3 + > +struct map4 + : m_item< + 4 + , typename P3::first + , typename P3::second + , map3< P0,P1,P2 > + > +{ + typedef map4 type; +}; + +template<> +struct m_at_impl<4> +{ + template< typename Map > struct result_ + { + typedef typename Map::item4 type; + }; +}; + +template<> +struct m_item_impl<5> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item4; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + > +struct map5 + : m_item< + 5 + , typename P4::first + , typename P4::second + , map4< P0,P1,P2,P3 > + > +{ + typedef map5 type; +}; + +template<> +struct m_at_impl<5> +{ + template< typename Map > struct result_ + { + typedef typename Map::item5 type; + }; +}; + +template<> +struct m_item_impl<6> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item5; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5 + > +struct map6 + : m_item< + 6 + , typename P5::first + , typename P5::second + , map5< P0,P1,P2,P3,P4 > + > +{ + typedef map6 type; +}; + +template<> +struct m_at_impl<6> +{ + template< typename Map > struct result_ + { + typedef typename Map::item6 type; + }; +}; + +template<> +struct m_item_impl<7> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item6; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6 + > +struct map7 + : m_item< + 7 + , typename P6::first + , typename P6::second + , map6< P0,P1,P2,P3,P4,P5 > + > +{ + typedef map7 type; +}; + +template<> +struct m_at_impl<7> +{ + template< typename Map > struct result_ + { + typedef typename Map::item7 type; + }; +}; + +template<> +struct m_item_impl<8> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item7; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7 + > +struct map8 + : m_item< + 8 + , typename P7::first + , typename P7::second + , map7< P0,P1,P2,P3,P4,P5,P6 > + > +{ + typedef map8 type; +}; + +template<> +struct m_at_impl<8> +{ + template< typename Map > struct result_ + { + typedef typename Map::item8 type; + }; +}; + +template<> +struct m_item_impl<9> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item8; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8 + > +struct map9 + : m_item< + 9 + , typename P8::first + , typename P8::second + , map8< P0,P1,P2,P3,P4,P5,P6,P7 > + > +{ + typedef map9 type; +}; + +template<> +struct m_at_impl<9> +{ + template< typename Map > struct result_ + { + typedef typename Map::item9 type; + }; +}; + +template<> +struct m_item_impl<10> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item9; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + > +struct map10 + : m_item< + 10 + , typename P9::first + , typename P9::second + , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 > + > +{ + typedef map10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp new file mode 100644 index 0000000000..ac9e3791c5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp @@ -0,0 +1,370 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template<> +struct m_at_impl<10> +{ + template< typename Map > struct result_ + { + typedef typename Map::item10 type; + }; +}; + +template<> +struct m_item_impl<11> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item10; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10 + > +struct map11 + : m_item< + 11 + , typename P10::first + , typename P10::second + , map10< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9 > + > +{ + typedef map11 type; +}; + +template<> +struct m_at_impl<11> +{ + template< typename Map > struct result_ + { + typedef typename Map::item11 type; + }; +}; + +template<> +struct m_item_impl<12> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item11; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11 + > +struct map12 + : m_item< + 12 + , typename P11::first + , typename P11::second + , map11< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10 > + > +{ + typedef map12 type; +}; + +template<> +struct m_at_impl<12> +{ + template< typename Map > struct result_ + { + typedef typename Map::item12 type; + }; +}; + +template<> +struct m_item_impl<13> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item12; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12 + > +struct map13 + : m_item< + 13 + , typename P12::first + , typename P12::second + , map12< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11 > + > +{ + typedef map13 type; +}; + +template<> +struct m_at_impl<13> +{ + template< typename Map > struct result_ + { + typedef typename Map::item13 type; + }; +}; + +template<> +struct m_item_impl<14> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item13; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13 + > +struct map14 + : m_item< + 14 + , typename P13::first + , typename P13::second + , map13< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12 > + > +{ + typedef map14 type; +}; + +template<> +struct m_at_impl<14> +{ + template< typename Map > struct result_ + { + typedef typename Map::item14 type; + }; +}; + +template<> +struct m_item_impl<15> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item14; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + > +struct map15 + : m_item< + 15 + , typename P14::first + , typename P14::second + , map14< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13 > + > +{ + typedef map15 type; +}; + +template<> +struct m_at_impl<15> +{ + template< typename Map > struct result_ + { + typedef typename Map::item15 type; + }; +}; + +template<> +struct m_item_impl<16> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item15; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15 + > +struct map16 + : m_item< + 16 + , typename P15::first + , typename P15::second + , map15< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14 > + > +{ + typedef map16 type; +}; + +template<> +struct m_at_impl<16> +{ + template< typename Map > struct result_ + { + typedef typename Map::item16 type; + }; +}; + +template<> +struct m_item_impl<17> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item16; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16 + > +struct map17 + : m_item< + 17 + , typename P16::first + , typename P16::second + , map16< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15 > + > +{ + typedef map17 type; +}; + +template<> +struct m_at_impl<17> +{ + template< typename Map > struct result_ + { + typedef typename Map::item17 type; + }; +}; + +template<> +struct m_item_impl<18> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item17; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17 + > +struct map18 + : m_item< + 18 + , typename P17::first + , typename P17::second + , map17< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16 > + > +{ + typedef map18 type; +}; + +template<> +struct m_at_impl<18> +{ + template< typename Map > struct result_ + { + typedef typename Map::item18 type; + }; +}; + +template<> +struct m_item_impl<19> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item18; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18 + > +struct map19 + : m_item< + 19 + , typename P18::first + , typename P18::second + , map18< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17 > + > +{ + typedef map19 type; +}; + +template<> +struct m_at_impl<19> +{ + template< typename Map > struct result_ + { + typedef typename Map::item19 type; + }; +}; + +template<> +struct m_item_impl<20> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item19; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + > +struct map20 + : m_item< + 20 + , typename P19::first + , typename P19::second + , map19< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18 > + > +{ + typedef map20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp new file mode 100644 index 0000000000..5aa118f224 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp @@ -0,0 +1,390 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template<> +struct m_at_impl<20> +{ + template< typename Map > struct result_ + { + typedef typename Map::item20 type; + }; +}; + +template<> +struct m_item_impl<21> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item20; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20 + > +struct map21 + : m_item< + 21 + , typename P20::first + , typename P20::second + , map20< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19 > + > +{ + typedef map21 type; +}; + +template<> +struct m_at_impl<21> +{ + template< typename Map > struct result_ + { + typedef typename Map::item21 type; + }; +}; + +template<> +struct m_item_impl<22> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item21; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21 + > +struct map22 + : m_item< + 22 + , typename P21::first + , typename P21::second + , map21< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20 > + > +{ + typedef map22 type; +}; + +template<> +struct m_at_impl<22> +{ + template< typename Map > struct result_ + { + typedef typename Map::item22 type; + }; +}; + +template<> +struct m_item_impl<23> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item22; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22 + > +struct map23 + : m_item< + 23 + , typename P22::first + , typename P22::second + , map22< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21 > + > +{ + typedef map23 type; +}; + +template<> +struct m_at_impl<23> +{ + template< typename Map > struct result_ + { + typedef typename Map::item23 type; + }; +}; + +template<> +struct m_item_impl<24> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item23; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23 + > +struct map24 + : m_item< + 24 + , typename P23::first + , typename P23::second + , map23< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22 > + > +{ + typedef map24 type; +}; + +template<> +struct m_at_impl<24> +{ + template< typename Map > struct result_ + { + typedef typename Map::item24 type; + }; +}; + +template<> +struct m_item_impl<25> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item24; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + > +struct map25 + : m_item< + 25 + , typename P24::first + , typename P24::second + , map24< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23 > + > +{ + typedef map25 type; +}; + +template<> +struct m_at_impl<25> +{ + template< typename Map > struct result_ + { + typedef typename Map::item25 type; + }; +}; + +template<> +struct m_item_impl<26> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item25; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25 + > +struct map26 + : m_item< + 26 + , typename P25::first + , typename P25::second + , map25< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24 > + > +{ + typedef map26 type; +}; + +template<> +struct m_at_impl<26> +{ + template< typename Map > struct result_ + { + typedef typename Map::item26 type; + }; +}; + +template<> +struct m_item_impl<27> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item26; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26 + > +struct map27 + : m_item< + 27 + , typename P26::first + , typename P26::second + , map26< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25 > + > +{ + typedef map27 type; +}; + +template<> +struct m_at_impl<27> +{ + template< typename Map > struct result_ + { + typedef typename Map::item27 type; + }; +}; + +template<> +struct m_item_impl<28> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item27; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27 + > +struct map28 + : m_item< + 28 + , typename P27::first + , typename P27::second + , map27< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26 > + > +{ + typedef map28 type; +}; + +template<> +struct m_at_impl<28> +{ + template< typename Map > struct result_ + { + typedef typename Map::item28 type; + }; +}; + +template<> +struct m_item_impl<29> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item28; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28 + > +struct map29 + : m_item< + 29 + , typename P28::first + , typename P28::second + , map28< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27 > + > +{ + typedef map29 type; +}; + +template<> +struct m_at_impl<29> +{ + template< typename Map > struct result_ + { + typedef typename Map::item29 type; + }; +}; + +template<> +struct m_item_impl<30> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item29; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + > +struct map30 + : m_item< + 30 + , typename P29::first + , typename P29::second + , map29< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28 > + > +{ + typedef map30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp new file mode 100644 index 0000000000..dca60d5e4a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp @@ -0,0 +1,410 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template<> +struct m_at_impl<30> +{ + template< typename Map > struct result_ + { + typedef typename Map::item30 type; + }; +}; + +template<> +struct m_item_impl<31> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item30; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30 + > +struct map31 + : m_item< + 31 + , typename P30::first + , typename P30::second + , map30< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29 > + > +{ + typedef map31 type; +}; + +template<> +struct m_at_impl<31> +{ + template< typename Map > struct result_ + { + typedef typename Map::item31 type; + }; +}; + +template<> +struct m_item_impl<32> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item31; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31 + > +struct map32 + : m_item< + 32 + , typename P31::first + , typename P31::second + , map31< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30 > + > +{ + typedef map32 type; +}; + +template<> +struct m_at_impl<32> +{ + template< typename Map > struct result_ + { + typedef typename Map::item32 type; + }; +}; + +template<> +struct m_item_impl<33> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item32; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32 + > +struct map33 + : m_item< + 33 + , typename P32::first + , typename P32::second + , map32< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31 > + > +{ + typedef map33 type; +}; + +template<> +struct m_at_impl<33> +{ + template< typename Map > struct result_ + { + typedef typename Map::item33 type; + }; +}; + +template<> +struct m_item_impl<34> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item33; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33 + > +struct map34 + : m_item< + 34 + , typename P33::first + , typename P33::second + , map33< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32 > + > +{ + typedef map34 type; +}; + +template<> +struct m_at_impl<34> +{ + template< typename Map > struct result_ + { + typedef typename Map::item34 type; + }; +}; + +template<> +struct m_item_impl<35> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item34; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + > +struct map35 + : m_item< + 35 + , typename P34::first + , typename P34::second + , map34< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33 > + > +{ + typedef map35 type; +}; + +template<> +struct m_at_impl<35> +{ + template< typename Map > struct result_ + { + typedef typename Map::item35 type; + }; +}; + +template<> +struct m_item_impl<36> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item35; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35 + > +struct map36 + : m_item< + 36 + , typename P35::first + , typename P35::second + , map35< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34 > + > +{ + typedef map36 type; +}; + +template<> +struct m_at_impl<36> +{ + template< typename Map > struct result_ + { + typedef typename Map::item36 type; + }; +}; + +template<> +struct m_item_impl<37> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item36; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36 + > +struct map37 + : m_item< + 37 + , typename P36::first + , typename P36::second + , map36< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35 > + > +{ + typedef map37 type; +}; + +template<> +struct m_at_impl<37> +{ + template< typename Map > struct result_ + { + typedef typename Map::item37 type; + }; +}; + +template<> +struct m_item_impl<38> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item37; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37 + > +struct map38 + : m_item< + 38 + , typename P37::first + , typename P37::second + , map37< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36 > + > +{ + typedef map38 type; +}; + +template<> +struct m_at_impl<38> +{ + template< typename Map > struct result_ + { + typedef typename Map::item38 type; + }; +}; + +template<> +struct m_item_impl<39> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item38; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38 + > +struct map39 + : m_item< + 39 + , typename P38::first + , typename P38::second + , map38< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37 > + > +{ + typedef map39 type; +}; + +template<> +struct m_at_impl<39> +{ + template< typename Map > struct result_ + { + typedef typename Map::item39 type; + }; +}; + +template<> +struct m_item_impl<40> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item39; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + > +struct map40 + : m_item< + 40 + , typename P39::first + , typename P39::second + , map39< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38 > + > +{ + typedef map40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp new file mode 100644 index 0000000000..cd8190887f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp @@ -0,0 +1,430 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template<> +struct m_at_impl<40> +{ + template< typename Map > struct result_ + { + typedef typename Map::item40 type; + }; +}; + +template<> +struct m_item_impl<41> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item40; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40 + > +struct map41 + : m_item< + 41 + , typename P40::first + , typename P40::second + , map40< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39 > + > +{ + typedef map41 type; +}; + +template<> +struct m_at_impl<41> +{ + template< typename Map > struct result_ + { + typedef typename Map::item41 type; + }; +}; + +template<> +struct m_item_impl<42> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item41; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41 + > +struct map42 + : m_item< + 42 + , typename P41::first + , typename P41::second + , map41< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40 > + > +{ + typedef map42 type; +}; + +template<> +struct m_at_impl<42> +{ + template< typename Map > struct result_ + { + typedef typename Map::item42 type; + }; +}; + +template<> +struct m_item_impl<43> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item42; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42 + > +struct map43 + : m_item< + 43 + , typename P42::first + , typename P42::second + , map42< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41 > + > +{ + typedef map43 type; +}; + +template<> +struct m_at_impl<43> +{ + template< typename Map > struct result_ + { + typedef typename Map::item43 type; + }; +}; + +template<> +struct m_item_impl<44> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item43; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43 + > +struct map44 + : m_item< + 44 + , typename P43::first + , typename P43::second + , map43< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42 > + > +{ + typedef map44 type; +}; + +template<> +struct m_at_impl<44> +{ + template< typename Map > struct result_ + { + typedef typename Map::item44 type; + }; +}; + +template<> +struct m_item_impl<45> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item44; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + > +struct map45 + : m_item< + 45 + , typename P44::first + , typename P44::second + , map44< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43 > + > +{ + typedef map45 type; +}; + +template<> +struct m_at_impl<45> +{ + template< typename Map > struct result_ + { + typedef typename Map::item45 type; + }; +}; + +template<> +struct m_item_impl<46> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item45; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45 + > +struct map46 + : m_item< + 46 + , typename P45::first + , typename P45::second + , map45< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44 > + > +{ + typedef map46 type; +}; + +template<> +struct m_at_impl<46> +{ + template< typename Map > struct result_ + { + typedef typename Map::item46 type; + }; +}; + +template<> +struct m_item_impl<47> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item46; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46 + > +struct map47 + : m_item< + 47 + , typename P46::first + , typename P46::second + , map46< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45 > + > +{ + typedef map47 type; +}; + +template<> +struct m_at_impl<47> +{ + template< typename Map > struct result_ + { + typedef typename Map::item47 type; + }; +}; + +template<> +struct m_item_impl<48> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item47; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47 + > +struct map48 + : m_item< + 48 + , typename P47::first + , typename P47::second + , map47< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46 > + > +{ + typedef map48 type; +}; + +template<> +struct m_at_impl<48> +{ + template< typename Map > struct result_ + { + typedef typename Map::item48 type; + }; +}; + +template<> +struct m_item_impl<49> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item48; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47, typename P48 + > +struct map49 + : m_item< + 49 + , typename P48::first + , typename P48::second + , map48< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47 > + > +{ + typedef map49 type; +}; + +template<> +struct m_at_impl<49> +{ + template< typename Map > struct result_ + { + typedef typename Map::item49 type; + }; +}; + +template<> +struct m_item_impl<50> +{ + template< typename Key, typename T, typename Base > struct result_ + : m_item_< Key,T,Base > + { + typedef pair< Key,T > item49; + }; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47, typename P48, typename P49 + > +struct map50 + : m_item< + 50 + , typename P49::first + , typename P49::second + , map49< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47,P48 > + > +{ + typedef map50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map10.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map10.hpp new file mode 100644 index 0000000000..ce0d2fb86f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map10.hpp @@ -0,0 +1,290 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename Map> +struct m_at< Map,0 > +{ + typedef typename Map::item0 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 1,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item0; +}; + +template< + typename P0 + > +struct map1 + : m_item< + 1 + , typename P0::first + , typename P0::second + , map0< > + > +{ + typedef map1 type; +}; + +template< typename Map> +struct m_at< Map,1 > +{ + typedef typename Map::item1 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 2,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item1; +}; + +template< + typename P0, typename P1 + > +struct map2 + : m_item< + 2 + , typename P1::first + , typename P1::second + , map1 + > +{ + typedef map2 type; +}; + +template< typename Map> +struct m_at< Map,2 > +{ + typedef typename Map::item2 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 3,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item2; +}; + +template< + typename P0, typename P1, typename P2 + > +struct map3 + : m_item< + 3 + , typename P2::first + , typename P2::second + , map2< P0,P1 > + > +{ + typedef map3 type; +}; + +template< typename Map> +struct m_at< Map,3 > +{ + typedef typename Map::item3 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 4,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item3; +}; + +template< + typename P0, typename P1, typename P2, typename P3 + > +struct map4 + : m_item< + 4 + , typename P3::first + , typename P3::second + , map3< P0,P1,P2 > + > +{ + typedef map4 type; +}; + +template< typename Map> +struct m_at< Map,4 > +{ + typedef typename Map::item4 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 5,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item4; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + > +struct map5 + : m_item< + 5 + , typename P4::first + , typename P4::second + , map4< P0,P1,P2,P3 > + > +{ + typedef map5 type; +}; + +template< typename Map> +struct m_at< Map,5 > +{ + typedef typename Map::item5 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 6,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item5; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5 + > +struct map6 + : m_item< + 6 + , typename P5::first + , typename P5::second + , map5< P0,P1,P2,P3,P4 > + > +{ + typedef map6 type; +}; + +template< typename Map> +struct m_at< Map,6 > +{ + typedef typename Map::item6 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 7,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item6; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6 + > +struct map7 + : m_item< + 7 + , typename P6::first + , typename P6::second + , map6< P0,P1,P2,P3,P4,P5 > + > +{ + typedef map7 type; +}; + +template< typename Map> +struct m_at< Map,7 > +{ + typedef typename Map::item7 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 8,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item7; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7 + > +struct map8 + : m_item< + 8 + , typename P7::first + , typename P7::second + , map7< P0,P1,P2,P3,P4,P5,P6 > + > +{ + typedef map8 type; +}; + +template< typename Map> +struct m_at< Map,8 > +{ + typedef typename Map::item8 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 9,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item8; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8 + > +struct map9 + : m_item< + 9 + , typename P8::first + , typename P8::second + , map8< P0,P1,P2,P3,P4,P5,P6,P7 > + > +{ + typedef map9 type; +}; + +template< typename Map> +struct m_at< Map,9 > +{ + typedef typename Map::item9 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 10,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item9; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + > +struct map10 + : m_item< + 10 + , typename P9::first + , typename P9::second + , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 > + > +{ + typedef map10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map20.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map20.hpp new file mode 100644 index 0000000000..e0a147cbdb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map20.hpp @@ -0,0 +1,310 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename Map> +struct m_at< Map,10 > +{ + typedef typename Map::item10 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 11,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item10; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10 + > +struct map11 + : m_item< + 11 + , typename P10::first + , typename P10::second + , map10< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9 > + > +{ + typedef map11 type; +}; + +template< typename Map> +struct m_at< Map,11 > +{ + typedef typename Map::item11 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 12,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item11; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11 + > +struct map12 + : m_item< + 12 + , typename P11::first + , typename P11::second + , map11< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10 > + > +{ + typedef map12 type; +}; + +template< typename Map> +struct m_at< Map,12 > +{ + typedef typename Map::item12 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 13,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item12; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12 + > +struct map13 + : m_item< + 13 + , typename P12::first + , typename P12::second + , map12< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11 > + > +{ + typedef map13 type; +}; + +template< typename Map> +struct m_at< Map,13 > +{ + typedef typename Map::item13 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 14,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item13; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13 + > +struct map14 + : m_item< + 14 + , typename P13::first + , typename P13::second + , map13< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12 > + > +{ + typedef map14 type; +}; + +template< typename Map> +struct m_at< Map,14 > +{ + typedef typename Map::item14 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 15,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item14; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + > +struct map15 + : m_item< + 15 + , typename P14::first + , typename P14::second + , map14< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13 > + > +{ + typedef map15 type; +}; + +template< typename Map> +struct m_at< Map,15 > +{ + typedef typename Map::item15 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 16,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item15; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15 + > +struct map16 + : m_item< + 16 + , typename P15::first + , typename P15::second + , map15< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14 > + > +{ + typedef map16 type; +}; + +template< typename Map> +struct m_at< Map,16 > +{ + typedef typename Map::item16 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 17,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item16; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16 + > +struct map17 + : m_item< + 17 + , typename P16::first + , typename P16::second + , map16< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15 > + > +{ + typedef map17 type; +}; + +template< typename Map> +struct m_at< Map,17 > +{ + typedef typename Map::item17 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 18,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item17; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17 + > +struct map18 + : m_item< + 18 + , typename P17::first + , typename P17::second + , map17< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16 > + > +{ + typedef map18 type; +}; + +template< typename Map> +struct m_at< Map,18 > +{ + typedef typename Map::item18 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 19,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item18; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18 + > +struct map19 + : m_item< + 19 + , typename P18::first + , typename P18::second + , map18< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17 > + > +{ + typedef map19 type; +}; + +template< typename Map> +struct m_at< Map,19 > +{ + typedef typename Map::item19 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 20,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item19; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + > +struct map20 + : m_item< + 20 + , typename P19::first + , typename P19::second + , map19< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18 > + > +{ + typedef map20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map30.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map30.hpp new file mode 100644 index 0000000000..d2f2e17b1c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map30.hpp @@ -0,0 +1,330 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename Map> +struct m_at< Map,20 > +{ + typedef typename Map::item20 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 21,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item20; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20 + > +struct map21 + : m_item< + 21 + , typename P20::first + , typename P20::second + , map20< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19 > + > +{ + typedef map21 type; +}; + +template< typename Map> +struct m_at< Map,21 > +{ + typedef typename Map::item21 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 22,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item21; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21 + > +struct map22 + : m_item< + 22 + , typename P21::first + , typename P21::second + , map21< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20 > + > +{ + typedef map22 type; +}; + +template< typename Map> +struct m_at< Map,22 > +{ + typedef typename Map::item22 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 23,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item22; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22 + > +struct map23 + : m_item< + 23 + , typename P22::first + , typename P22::second + , map22< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21 > + > +{ + typedef map23 type; +}; + +template< typename Map> +struct m_at< Map,23 > +{ + typedef typename Map::item23 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 24,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item23; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23 + > +struct map24 + : m_item< + 24 + , typename P23::first + , typename P23::second + , map23< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22 > + > +{ + typedef map24 type; +}; + +template< typename Map> +struct m_at< Map,24 > +{ + typedef typename Map::item24 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 25,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item24; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + > +struct map25 + : m_item< + 25 + , typename P24::first + , typename P24::second + , map24< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23 > + > +{ + typedef map25 type; +}; + +template< typename Map> +struct m_at< Map,25 > +{ + typedef typename Map::item25 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 26,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item25; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25 + > +struct map26 + : m_item< + 26 + , typename P25::first + , typename P25::second + , map25< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24 > + > +{ + typedef map26 type; +}; + +template< typename Map> +struct m_at< Map,26 > +{ + typedef typename Map::item26 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 27,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item26; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26 + > +struct map27 + : m_item< + 27 + , typename P26::first + , typename P26::second + , map26< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25 > + > +{ + typedef map27 type; +}; + +template< typename Map> +struct m_at< Map,27 > +{ + typedef typename Map::item27 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 28,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item27; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27 + > +struct map28 + : m_item< + 28 + , typename P27::first + , typename P27::second + , map27< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26 > + > +{ + typedef map28 type; +}; + +template< typename Map> +struct m_at< Map,28 > +{ + typedef typename Map::item28 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 29,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item28; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28 + > +struct map29 + : m_item< + 29 + , typename P28::first + , typename P28::second + , map28< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27 > + > +{ + typedef map29 type; +}; + +template< typename Map> +struct m_at< Map,29 > +{ + typedef typename Map::item29 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 30,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item29; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + > +struct map30 + : m_item< + 30 + , typename P29::first + , typename P29::second + , map29< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28 > + > +{ + typedef map30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map40.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map40.hpp new file mode 100644 index 0000000000..692f014c65 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map40.hpp @@ -0,0 +1,350 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename Map> +struct m_at< Map,30 > +{ + typedef typename Map::item30 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 31,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item30; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30 + > +struct map31 + : m_item< + 31 + , typename P30::first + , typename P30::second + , map30< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29 > + > +{ + typedef map31 type; +}; + +template< typename Map> +struct m_at< Map,31 > +{ + typedef typename Map::item31 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 32,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item31; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31 + > +struct map32 + : m_item< + 32 + , typename P31::first + , typename P31::second + , map31< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30 > + > +{ + typedef map32 type; +}; + +template< typename Map> +struct m_at< Map,32 > +{ + typedef typename Map::item32 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 33,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item32; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32 + > +struct map33 + : m_item< + 33 + , typename P32::first + , typename P32::second + , map32< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31 > + > +{ + typedef map33 type; +}; + +template< typename Map> +struct m_at< Map,33 > +{ + typedef typename Map::item33 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 34,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item33; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33 + > +struct map34 + : m_item< + 34 + , typename P33::first + , typename P33::second + , map33< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32 > + > +{ + typedef map34 type; +}; + +template< typename Map> +struct m_at< Map,34 > +{ + typedef typename Map::item34 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 35,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item34; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + > +struct map35 + : m_item< + 35 + , typename P34::first + , typename P34::second + , map34< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33 > + > +{ + typedef map35 type; +}; + +template< typename Map> +struct m_at< Map,35 > +{ + typedef typename Map::item35 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 36,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item35; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35 + > +struct map36 + : m_item< + 36 + , typename P35::first + , typename P35::second + , map35< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34 > + > +{ + typedef map36 type; +}; + +template< typename Map> +struct m_at< Map,36 > +{ + typedef typename Map::item36 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 37,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item36; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36 + > +struct map37 + : m_item< + 37 + , typename P36::first + , typename P36::second + , map36< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35 > + > +{ + typedef map37 type; +}; + +template< typename Map> +struct m_at< Map,37 > +{ + typedef typename Map::item37 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 38,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item37; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37 + > +struct map38 + : m_item< + 38 + , typename P37::first + , typename P37::second + , map37< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36 > + > +{ + typedef map38 type; +}; + +template< typename Map> +struct m_at< Map,38 > +{ + typedef typename Map::item38 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 39,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item38; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38 + > +struct map39 + : m_item< + 39 + , typename P38::first + , typename P38::second + , map38< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37 > + > +{ + typedef map39 type; +}; + +template< typename Map> +struct m_at< Map,39 > +{ + typedef typename Map::item39 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 40,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item39; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + > +struct map40 + : m_item< + 40 + , typename P39::first + , typename P39::second + , map39< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38 > + > +{ + typedef map40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map50.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map50.hpp new file mode 100644 index 0000000000..3bd2a25a31 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/plain/map50.hpp @@ -0,0 +1,370 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename Map> +struct m_at< Map,40 > +{ + typedef typename Map::item40 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 41,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item40; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40 + > +struct map41 + : m_item< + 41 + , typename P40::first + , typename P40::second + , map40< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39 > + > +{ + typedef map41 type; +}; + +template< typename Map> +struct m_at< Map,41 > +{ + typedef typename Map::item41 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 42,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item41; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41 + > +struct map42 + : m_item< + 42 + , typename P41::first + , typename P41::second + , map41< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40 > + > +{ + typedef map42 type; +}; + +template< typename Map> +struct m_at< Map,42 > +{ + typedef typename Map::item42 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 43,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item42; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42 + > +struct map43 + : m_item< + 43 + , typename P42::first + , typename P42::second + , map42< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41 > + > +{ + typedef map43 type; +}; + +template< typename Map> +struct m_at< Map,43 > +{ + typedef typename Map::item43 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 44,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item43; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43 + > +struct map44 + : m_item< + 44 + , typename P43::first + , typename P43::second + , map43< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42 > + > +{ + typedef map44 type; +}; + +template< typename Map> +struct m_at< Map,44 > +{ + typedef typename Map::item44 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 45,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item44; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + > +struct map45 + : m_item< + 45 + , typename P44::first + , typename P44::second + , map44< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43 > + > +{ + typedef map45 type; +}; + +template< typename Map> +struct m_at< Map,45 > +{ + typedef typename Map::item45 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 46,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item45; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45 + > +struct map46 + : m_item< + 46 + , typename P45::first + , typename P45::second + , map45< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44 > + > +{ + typedef map46 type; +}; + +template< typename Map> +struct m_at< Map,46 > +{ + typedef typename Map::item46 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 47,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item46; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46 + > +struct map47 + : m_item< + 47 + , typename P46::first + , typename P46::second + , map46< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45 > + > +{ + typedef map47 type; +}; + +template< typename Map> +struct m_at< Map,47 > +{ + typedef typename Map::item47 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 48,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item47; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47 + > +struct map48 + : m_item< + 48 + , typename P47::first + , typename P47::second + , map47< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46 > + > +{ + typedef map48 type; +}; + +template< typename Map> +struct m_at< Map,48 > +{ + typedef typename Map::item48 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 49,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item48; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47, typename P48 + > +struct map49 + : m_item< + 49 + , typename P48::first + , typename P48::second + , map48< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47 > + > +{ + typedef map49 type; +}; + +template< typename Map> +struct m_at< Map,49 > +{ + typedef typename Map::item49 type; +}; + +template< typename Key, typename T, typename Base > +struct m_item< 50,Key,T,Base > + : m_item_< Key,T,Base > +{ + typedef pair< Key,T > item49; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47, typename P48, typename P49 + > +struct map50 + : m_item< + 50 + , typename P49::first + , typename P49::second + , map49< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47,P48 > + > +{ + typedef map50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp new file mode 100644 index 0000000000..e48e9919ce --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp @@ -0,0 +1,150 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename P0 + > +struct map1 + : m_item< + typename P0::first + , typename P0::second + , map0< > + > +{ + typedef map1 type; +}; + +template< + typename P0, typename P1 + > +struct map2 + : m_item< + typename P1::first + , typename P1::second + , map1 + > +{ + typedef map2 type; +}; + +template< + typename P0, typename P1, typename P2 + > +struct map3 + : m_item< + typename P2::first + , typename P2::second + , map2< P0,P1 > + > +{ + typedef map3 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3 + > +struct map4 + : m_item< + typename P3::first + , typename P3::second + , map3< P0,P1,P2 > + > +{ + typedef map4 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + > +struct map5 + : m_item< + typename P4::first + , typename P4::second + , map4< P0,P1,P2,P3 > + > +{ + typedef map5 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5 + > +struct map6 + : m_item< + typename P5::first + , typename P5::second + , map5< P0,P1,P2,P3,P4 > + > +{ + typedef map6 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6 + > +struct map7 + : m_item< + typename P6::first + , typename P6::second + , map6< P0,P1,P2,P3,P4,P5 > + > +{ + typedef map7 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7 + > +struct map8 + : m_item< + typename P7::first + , typename P7::second + , map7< P0,P1,P2,P3,P4,P5,P6 > + > +{ + typedef map8 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8 + > +struct map9 + : m_item< + typename P8::first + , typename P8::second + , map8< P0,P1,P2,P3,P4,P5,P6,P7 > + > +{ + typedef map9 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + > +struct map10 + : m_item< + typename P9::first + , typename P9::second + , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 > + > +{ + typedef map10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp new file mode 100644 index 0000000000..bb8d3881e0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp @@ -0,0 +1,170 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10 + > +struct map11 + : m_item< + typename P10::first + , typename P10::second + , map10< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9 > + > +{ + typedef map11 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11 + > +struct map12 + : m_item< + typename P11::first + , typename P11::second + , map11< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10 > + > +{ + typedef map12 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12 + > +struct map13 + : m_item< + typename P12::first + , typename P12::second + , map12< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11 > + > +{ + typedef map13 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13 + > +struct map14 + : m_item< + typename P13::first + , typename P13::second + , map13< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12 > + > +{ + typedef map14 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + > +struct map15 + : m_item< + typename P14::first + , typename P14::second + , map14< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13 > + > +{ + typedef map15 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15 + > +struct map16 + : m_item< + typename P15::first + , typename P15::second + , map15< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14 > + > +{ + typedef map16 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16 + > +struct map17 + : m_item< + typename P16::first + , typename P16::second + , map16< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15 > + > +{ + typedef map17 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17 + > +struct map18 + : m_item< + typename P17::first + , typename P17::second + , map17< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16 > + > +{ + typedef map18 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18 + > +struct map19 + : m_item< + typename P18::first + , typename P18::second + , map18< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17 > + > +{ + typedef map19 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + > +struct map20 + : m_item< + typename P19::first + , typename P19::second + , map19< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18 > + > +{ + typedef map20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp new file mode 100644 index 0000000000..6a45c0d6a2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp @@ -0,0 +1,190 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20 + > +struct map21 + : m_item< + typename P20::first + , typename P20::second + , map20< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19 > + > +{ + typedef map21 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21 + > +struct map22 + : m_item< + typename P21::first + , typename P21::second + , map21< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20 > + > +{ + typedef map22 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22 + > +struct map23 + : m_item< + typename P22::first + , typename P22::second + , map22< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21 > + > +{ + typedef map23 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23 + > +struct map24 + : m_item< + typename P23::first + , typename P23::second + , map23< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22 > + > +{ + typedef map24 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + > +struct map25 + : m_item< + typename P24::first + , typename P24::second + , map24< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23 > + > +{ + typedef map25 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25 + > +struct map26 + : m_item< + typename P25::first + , typename P25::second + , map25< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24 > + > +{ + typedef map26 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26 + > +struct map27 + : m_item< + typename P26::first + , typename P26::second + , map26< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25 > + > +{ + typedef map27 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27 + > +struct map28 + : m_item< + typename P27::first + , typename P27::second + , map27< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26 > + > +{ + typedef map28 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28 + > +struct map29 + : m_item< + typename P28::first + , typename P28::second + , map28< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27 > + > +{ + typedef map29 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + > +struct map30 + : m_item< + typename P29::first + , typename P29::second + , map29< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28 > + > +{ + typedef map30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp new file mode 100644 index 0000000000..6fc4f4b4a0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp @@ -0,0 +1,210 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30 + > +struct map31 + : m_item< + typename P30::first + , typename P30::second + , map30< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29 > + > +{ + typedef map31 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31 + > +struct map32 + : m_item< + typename P31::first + , typename P31::second + , map31< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30 > + > +{ + typedef map32 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32 + > +struct map33 + : m_item< + typename P32::first + , typename P32::second + , map32< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31 > + > +{ + typedef map33 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33 + > +struct map34 + : m_item< + typename P33::first + , typename P33::second + , map33< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32 > + > +{ + typedef map34 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + > +struct map35 + : m_item< + typename P34::first + , typename P34::second + , map34< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33 > + > +{ + typedef map35 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35 + > +struct map36 + : m_item< + typename P35::first + , typename P35::second + , map35< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34 > + > +{ + typedef map36 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36 + > +struct map37 + : m_item< + typename P36::first + , typename P36::second + , map36< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35 > + > +{ + typedef map37 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37 + > +struct map38 + : m_item< + typename P37::first + , typename P37::second + , map37< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36 > + > +{ + typedef map38 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38 + > +struct map39 + : m_item< + typename P38::first + , typename P38::second + , map38< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37 > + > +{ + typedef map39 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + > +struct map40 + : m_item< + typename P39::first + , typename P39::second + , map39< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38 > + > +{ + typedef map40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp new file mode 100644 index 0000000000..7b3980dfae --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp @@ -0,0 +1,230 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/map/map50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40 + > +struct map41 + : m_item< + typename P40::first + , typename P40::second + , map40< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39 > + > +{ + typedef map41 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41 + > +struct map42 + : m_item< + typename P41::first + , typename P41::second + , map41< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40 > + > +{ + typedef map42 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42 + > +struct map43 + : m_item< + typename P42::first + , typename P42::second + , map42< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41 > + > +{ + typedef map43 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43 + > +struct map44 + : m_item< + typename P43::first + , typename P43::second + , map43< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42 > + > +{ + typedef map44 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + > +struct map45 + : m_item< + typename P44::first + , typename P44::second + , map44< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43 > + > +{ + typedef map45 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45 + > +struct map46 + : m_item< + typename P45::first + , typename P45::second + , map45< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44 > + > +{ + typedef map46 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46 + > +struct map47 + : m_item< + typename P46::first + , typename P46::second + , map46< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45 > + > +{ + typedef map47 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47 + > +struct map48 + : m_item< + typename P47::first + , typename P47::second + , map47< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46 > + > +{ + typedef map48 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47, typename P48 + > +struct map49 + : m_item< + typename P48::first + , typename P48::second + , map48< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47 > + > +{ + typedef map49 type; +}; + +template< + typename P0, typename P1, typename P2, typename P3, typename P4 + , typename P5, typename P6, typename P7, typename P8, typename P9 + , typename P10, typename P11, typename P12, typename P13, typename P14 + , typename P15, typename P16, typename P17, typename P18, typename P19 + , typename P20, typename P21, typename P22, typename P23, typename P24 + , typename P25, typename P26, typename P27, typename P28, typename P29 + , typename P30, typename P31, typename P32, typename P33, typename P34 + , typename P35, typename P36, typename P37, typename P38, typename P39 + , typename P40, typename P41, typename P42, typename P43, typename P44 + , typename P45, typename P46, typename P47, typename P48, typename P49 + > +struct map50 + : m_item< + typename P49::first + , typename P49::second + , map49< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47,P48 > + > +{ + typedef map50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/size_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/size_impl.hpp new file mode 100644 index 0000000000..881a6484d4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/size_impl.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_MAP_AUX_SIZE_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_SIZE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/size_impl.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct size_impl< aux::map_tag > +{ + template< typename Map > struct apply + : Map::size + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_SIZE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/tag.hpp new file mode 100644 index 0000000000..a585b99075 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/tag.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/tag.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { namespace aux { + +struct map_tag; + +}}} + +#endif // BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/aux_/value_type_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/map/aux_/value_type_impl.hpp new file mode 100755 index 0000000000..bf64269db1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/aux_/value_type_impl.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_MAP_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED +#define BOOST_MPL_MAP_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/aux_/value_type_impl.hpp,v $ +// $Date: 2004/09/02 15:41:00 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { +namespace mpl { + +template<> +struct value_type_impl< aux::map_tag > +{ + template< typename Map, typename T > struct apply + : second + { + }; +}; + +}} + +#endif // BOOST_MPL_MAP_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/map0.hpp b/deal.II/contrib/boost/include/boost/mpl/map/map0.hpp new file mode 100644 index 0000000000..16fd46935c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/map0.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_MAP_MAP0_HPP_INCLUDED +#define BOOST_MPL_MAP_MAP0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/map0.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.2 $ + +#include +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_MPL_MAP_MAP0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/map10.hpp b/deal.II/contrib/boost/include/boost/mpl/map/map10.hpp new file mode 100644 index 0000000000..c5c05ab842 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/map10.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_MAP_MAP10_HPP_INCLUDED +#define BOOST_MPL_MAP_MAP10_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/map10.hpp,v $ +// $Date: 2004/09/05 09:42:58 $ +// $Revision: 1.3 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER map10.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_MAP_MAP10_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/map20.hpp b/deal.II/contrib/boost/include/boost/mpl/map/map20.hpp new file mode 100644 index 0000000000..a2e3a30729 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/map20.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_MAP_MAP20_HPP_INCLUDED +#define BOOST_MPL_MAP_MAP20_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/map20.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER map20.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_MAP_MAP20_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/map30.hpp b/deal.II/contrib/boost/include/boost/mpl/map/map30.hpp new file mode 100644 index 0000000000..0997fb7007 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/map30.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_MAP_MAP30_HPP_INCLUDED +#define BOOST_MPL_MAP_MAP30_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/map30.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER map30.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_MAP_MAP30_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/map40.hpp b/deal.II/contrib/boost/include/boost/mpl/map/map40.hpp new file mode 100644 index 0000000000..0f04472800 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/map40.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_MAP_MAP40_HPP_INCLUDED +#define BOOST_MPL_MAP_MAP40_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/map40.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER map40.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_MAP_MAP40_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/map/map50.hpp b/deal.II/contrib/boost/include/boost/mpl/map/map50.hpp new file mode 100644 index 0000000000..5580936262 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/map/map50.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_MAP_MAP50_HPP_INCLUDED +#define BOOST_MPL_MAP_MAP50_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/map/map50.hpp,v $ +// $Date: 2004/09/02 15:40:59 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER map50.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_MAP_MAP50_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/math/fixed_c.hpp b/deal.II/contrib/boost/include/boost/mpl/math/fixed_c.hpp new file mode 100644 index 0000000000..62feed163e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/math/fixed_c.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_FIXED_C_HPP_INCLUDED +#define BOOST_MPL_FIXED_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/math/fixed_c.hpp,v $ +// $Date: 2004/09/02 15:41:01 $ +// $Revision: 1.4 $ + +#include + +namespace boost { namespace mpl { + +template< + long IntegerPart + , unsigned long FractionPart + > +struct fixed_c +{ + BOOST_STATIC_CONSTANT(long, integer_part = IntegerPart); + BOOST_STATIC_CONSTANT(unsigned long, fraction_part = FractionPart); + typedef fixed_c type; + + fixed_c() {} +}; + +}} + +#endif // BOOST_MPL_FIXED_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/math/is_even.hpp b/deal.II/contrib/boost/include/boost/mpl/math/is_even.hpp new file mode 100644 index 0000000000..41dbafbb64 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/math/is_even.hpp @@ -0,0 +1,54 @@ + +#ifndef BOOST_MPL_MATH_IS_EVEN_HPP_INCLUDED +#define BOOST_MPL_MATH_IS_EVEN_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/math/is_even.hpp,v $ +// $Date: 2004/09/02 15:41:01 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +namespace aux +{ + template + struct is_even_base + { + enum { value = (N::value % 2) == 0 }; + typedef bool_ type; + }; +} +#endif + +template< + typename BOOST_MPL_AUX_NA_PARAM(N) + > +struct is_even +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + : aux::is_even_base::type +#else + : bool_<((N::value % 2) == 0)> +#endif +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_even,(N)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, is_even) + +}} + +#endif // BOOST_MPL_MATH_IS_EVEN_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/math/rational_c.hpp b/deal.II/contrib/boost/include/boost/mpl/math/rational_c.hpp new file mode 100644 index 0000000000..e99f06f7a0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/math/rational_c.hpp @@ -0,0 +1,37 @@ + +#ifndef BOOST_MPL_RATIONAL_C_HPP_INCLUDED +#define BOOST_MPL_RATIONAL_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/math/rational_c.hpp,v $ +// $Date: 2004/09/02 15:41:01 $ +// $Revision: 1.4 $ + +#include + +namespace boost { namespace mpl { + +template< + typename IntegerType + , IntegerType N + , IntegerType D = 1 + > +struct rational_c +{ + BOOST_STATIC_CONSTANT(IntegerType, numerator = N); + BOOST_STATIC_CONSTANT(IntegerType, denominator = D); + + typedef rational_c type; + rational_c() {} +}; + +}} + +#endif // BOOST_MPL_RATIONAL_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/max.hpp b/deal.II/contrib/boost/include/boost/mpl/max.hpp new file mode 100644 index 0000000000..b307f34ef3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/max.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_MAX_HPP_INCLUDED +#define BOOST_MPL_MAX_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/max.hpp,v $ +// $Date: 2004/11/28 01:55:27 $ +// $Revision: 1.2 $ + +#include + +#endif // BOOST_MPL_MAX_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/max_element.hpp b/deal.II/contrib/boost/include/boost/mpl/max_element.hpp new file mode 100644 index 0000000000..916ca2cb06 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/max_element.hpp @@ -0,0 +1,72 @@ + +#ifndef BOOST_MPL_MAX_ELEMENT_HPP_INCLUDED +#define BOOST_MPL_MAX_ELEMENT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/max_element.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_COMMON_NAME_WKND(max_element) + +namespace aux { + +template< typename Predicate > +struct select_max +{ + template< typename OldIterator, typename Iterator > + struct apply + { + typedef typename apply2< + Predicate + , typename deref::type + , typename deref::type + >::type condition_; + + typedef typename if_< + condition_ + , Iterator + , OldIterator + >::type type; + }; +}; + +} // namespace aux + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename Predicate = less<_,_> + > +struct max_element + : iter_fold< + Sequence + , typename begin::type + , protect< aux::select_max > + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(1, max_element) + +}} + +#endif // BOOST_MPL_MAX_ELEMENT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/min.hpp b/deal.II/contrib/boost/include/boost/mpl/min.hpp new file mode 100644 index 0000000000..34487c9299 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/min.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_MIN_HPP_INCLUDED +#define BOOST_MPL_MIN_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/min.hpp,v $ +// $Date: 2004/11/28 01:55:27 $ +// $Revision: 1.2 $ + +#include + +#endif // BOOST_MPL_MIN_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/min_element.hpp b/deal.II/contrib/boost/include/boost/mpl/min_element.hpp new file mode 100755 index 0000000000..9f4b00636d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/min_element.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_MIN_ELEMENT_HPP_INCLUDED +#define BOOST_MPL_MIN_ELEMENT_HPP_INCLUDED + +// Copyright David Abrahams 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/min_element.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_COMMON_NAME_WKND(min_element) + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename Predicate = less<_,_> + > +struct min_element + : max_element< + Sequence + , mpl::not_ + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(1, min_element) + +}} + +#endif // BOOST_MPL_MIN_ELEMENT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/min_max.hpp b/deal.II/contrib/boost/include/boost/mpl/min_max.hpp new file mode 100644 index 0000000000..f28b1c6d41 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/min_max.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_MAX_HPP_INCLUDED +#define BOOST_MPL_MAX_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/min_max.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct min + : if_< less,N1,N2 > +{ +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N1) + , typename BOOST_MPL_AUX_NA_PARAM(N2) + > +struct max + : if_< less,N2,N1 > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(2, min) +BOOST_MPL_AUX_NA_SPEC(2, max) + +}} + +#endif // BOOST_MPL_MAX_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/minus.hpp b/deal.II/contrib/boost/include/boost/mpl/minus.hpp new file mode 100644 index 0000000000..fe6e2ace65 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/minus.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_MINUS_HPP_INCLUDED +#define BOOST_MPL_MINUS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/minus.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME minus +#define AUX778076_OP_TOKEN - +#include + +#endif // BOOST_MPL_MINUS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/modulus.hpp b/deal.II/contrib/boost/include/boost/mpl/modulus.hpp new file mode 100644 index 0000000000..292e58e92f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/modulus.hpp @@ -0,0 +1,22 @@ + +#ifndef BOOST_MPL_MODULUS_HPP_INCLUDED +#define BOOST_MPL_MODULUS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/modulus.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME modulus +#define AUX778076_OP_TOKEN % +#define AUX778076_OP_ARITY 2 +#include + +#endif // BOOST_MPL_MODULUS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiplies.hpp b/deal.II/contrib/boost/include/boost/mpl/multiplies.hpp new file mode 100644 index 0000000000..14ae36144b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiplies.hpp @@ -0,0 +1,53 @@ + +#ifndef BOOST_MPL_MULTIPLIES_HPP_INCLUDED +#define BOOST_MPL_MULTIPLIES_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiplies.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include +#include + +// backward compatibility header, deprecated + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY +#else +# define AUX778076_OP_ARITY 2 +#endif + +template< + BOOST_MPL_PP_DEFAULT_PARAMS(AUX778076_OP_ARITY, typename N, na) + > +struct multiplies + : times< BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT( + AUX778076_OP_ARITY + , multiplies + , ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) ) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(AUX778076_OP_ARITY, multiplies) + +#undef AUX778076_OP_ARITY + +}} + +#endif // BOOST_MPL_MULTIPLIES_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/count_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/count_impl.hpp new file mode 100644 index 0000000000..0969dcee1d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/count_impl.hpp @@ -0,0 +1,82 @@ + +#ifndef BOOST_MPL_MULTISET_AUX_COUNT_IMPL_HPP_INCLUDED +#define BOOST_MPL_MULTISET_AUX_COUNT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiset/aux_/count_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# include +# include +#endif + +namespace boost { namespace mpl { + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +namespace aux { +template< typename S, typename U > +struct multiset_count_impl + : int_< sizeof(S::key_count(BOOST_MPL_AUX_STATIC_CAST(U*,0))) - 1 > +{ +}; + +template< typename S, typename U > +struct multiset_count_ref_impl +{ + typedef U (* u_)(); + typedef int_< sizeof(S::ref_key_count(BOOST_MPL_AUX_STATIC_CAST(u_,0))) - 1 > type_; + BOOST_STATIC_CONSTANT(int, value = type_::value); + typedef type_ type; +}; +} + +template<> +struct count_impl< aux::multiset_tag > +{ + template< typename Set, typename Key > struct apply + : if_< + is_reference + , aux::multiset_count_ref_impl + , aux::multiset_count_impl + >::type + { + }; +}; + +#else + +template<> +struct count_impl< aux::multiset_tag > +{ + template< typename Set, typename Key > struct apply + { + enum { msvc71_wknd_ = sizeof(Set::key_count(BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*,0))) - 1 }; + typedef int_< msvc71_wknd_ > type; + BOOST_STATIC_CONSTANT(int, value = msvc71_wknd_); + }; +}; + +#endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +}} + +#endif // BOOST_MPL_MULTISET_AUX_COUNT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/insert_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/insert_impl.hpp new file mode 100644 index 0000000000..60a25fc573 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/insert_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_MULTISET_AUX_INSERT_IMPL_HPP_INCLUDED +#define BOOST_MPL_MULTISET_AUX_INSERT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiset/aux_/insert_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct insert_impl< aux::multiset_tag > +{ + template< typename Set, typename Key, typename unused_ > struct apply + { + typedef ms_item type; + }; +}; + +}} + +#endif // BOOST_MPL_MULTISET_AUX_INSERT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/item.hpp b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/item.hpp new file mode 100644 index 0000000000..a102b0a6d5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/item.hpp @@ -0,0 +1,114 @@ + +#ifndef BOOST_MPL_MULTISET_AUX_ITEM_HPP_INCLUDED +#define BOOST_MPL_MULTISET_AUX_ITEM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiset/aux_/item.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# include +# include +# include +#endif + + +namespace boost { namespace mpl { + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +template< typename T, typename Base > +struct ms_item +{ + typedef aux::multiset_tag tag; + + template< typename U > struct prior_count + { + enum { msvc70_wknd_ = sizeof(Base::key_count(BOOST_MPL_AUX_STATIC_CAST(U*,0))) }; + typedef int_< msvc70_wknd_ > count_; + typedef typename eval_if< is_same, next, count_ >::type c_; +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + typedef typename aux::weighted_tag::type type; +#else + typedef char (&type)[BOOST_MPL_AUX_MSVC_VALUE_WKND(c_)::value]; +#endif + }; + + template< typename U > struct prior_ref_count + { + typedef U (* u_)(); + enum { msvc70_wknd_ = sizeof(Base::ref_key_count(BOOST_MPL_AUX_STATIC_CAST(u_,0))) }; + typedef int_< msvc70_wknd_ > count_; + typedef typename eval_if< is_same, next, count_ >::type c_; +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + typedef typename aux::weighted_tag::type type; +#else + typedef char (&type)[BOOST_MPL_AUX_MSVC_VALUE_WKND(c_)::value]; +#endif + }; + + template< typename U > + static typename prior_count::type key_count(U*); + + template< typename U > + static typename prior_ref_count::type ref_key_count(U (*)()); +}; + +#else // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +namespace aux { +template< typename U, typename Base > +struct prior_key_count +{ + enum { msvc71_wknd_ = sizeof(Base::key_count(BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*,0))) }; + typedef int_< msvc71_wknd_ > count_; +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + typedef typename aux::weighted_tag< BOOST_MPL_AUX_VALUE_WKND(count_)::value >::type type; +#else + typedef char (&type)[count_::value]; +#endif +}; +} + +template< typename T, typename Base > +struct ms_item +{ + typedef aux::multiset_tag tag; + + enum { msvc71_wknd_ = sizeof(Base::key_count(BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*,0))) + 1 }; + typedef int_< msvc71_wknd_ > count_; +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + static + typename aux::weighted_tag< BOOST_MPL_AUX_VALUE_WKND(count_)::value >::type + key_count(aux::type_wrapper*); +#else + static char (& key_count(aux::type_wrapper*) )[count_::value]; +#endif + + template< typename U > + static typename aux::prior_key_count::type key_count(aux::type_wrapper*); +}; + +#endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +}} + +#endif // BOOST_MPL_MULTISET_AUX_ITEM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/multiset0.hpp b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/multiset0.hpp new file mode 100644 index 0000000000..01cefada7c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/multiset0.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_MULTISET_AUX_MULTISET0_HPP_INCLUDED +#define BOOST_MPL_MULTISET_AUX_MULTISET0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiset/aux_/multiset0.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template< int dummy_ = 0 > +struct multiset0 +{ + typedef aux::multiset_tag tag; + + typedef int_<1> count_; + static char (& key_count(...) )[count_::value]; + static char (& ref_key_count(...) )[count_::value]; +}; + +}} + +#endif // BOOST_MPL_MULTISET_AUX_MULTISET0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/tag.hpp new file mode 100644 index 0000000000..c2e6164115 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiset/aux_/tag.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_MULTISET_AUX_TAG_HPP_INCLUDED +#define BOOST_MPL_MULTISET_AUX_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiset/aux_/tag.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { namespace aux { + +struct multiset_tag; + +}}} + +#endif // BOOST_MPL_MULTISET_AUX_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/multiset/multiset0.hpp b/deal.II/contrib/boost/include/boost/mpl/multiset/multiset0.hpp new file mode 100644 index 0000000000..9b23635fac --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/multiset/multiset0.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_MULTISET_MULTISET0_HPP_INCLUDED +#define BOOST_MPL_MULTISET_MULTISET0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/multiset/multiset0.hpp,v $ +// $Date: 2004/09/02 15:41:01 $ +// $Revision: 1.2 $ + +//#include +//#include +//#include +//#include +//#include +//#include +//#include +//#include +//#include +//#include +#include +#include +//#include +//#include +//#include +#include +#include +#include + +#endif // BOOST_MPL_MULTISET_MULTISET0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/negate.hpp b/deal.II/contrib/boost/include/boost/mpl/negate.hpp new file mode 100644 index 0000000000..5d158bc481 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/negate.hpp @@ -0,0 +1,81 @@ + +#ifndef BOOST_MPL_NEGATE_HPP_INCLUDED +#define BOOST_MPL_NEGATE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/negate.hpp,v $ +// $Date: 2004/09/07 09:06:08 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Tag > struct negate_impl; + +template< typename T > struct negate_tag +{ + typedef typename T::tag type; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(N) + > +struct negate +#if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) + : negate_impl< + typename negate_tag::type + >::template apply::type +#else + : aux::msvc_eti_base< typename apply_wrap1< + negate_impl< typename negate_tag::type > + , N + >::type >::type +#endif +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, negate, (N)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, negate) + + +#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) +namespace aux { +template< typename T, T n > struct negate_wknd +{ + BOOST_STATIC_CONSTANT(T, value = -n); + typedef integral_c type; +}; +} +#endif + +template<> +struct negate_impl +{ +#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) + template< typename N > struct apply + : aux::negate_wknd< typename N::value_type, N::value > +#else + template< typename N > struct apply + : integral_c< typename N::value_type, (-N::value) > +#endif + { + }; +}; + +}} + +#endif // BOOST_MPL_NEGATE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/next.hpp b/deal.II/contrib/boost/include/boost/mpl/next.hpp new file mode 100644 index 0000000000..3aec2236ff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/next.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_NEXT_HPP_INCLUDED +#define BOOST_MPL_NEXT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/next.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.7 $ + +#include + +#endif // BOOST_MPL_NEXT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/next_prior.hpp b/deal.II/contrib/boost/include/boost/mpl/next_prior.hpp new file mode 100644 index 0000000000..c8f4ca3ace --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/next_prior.hpp @@ -0,0 +1,49 @@ + +#ifndef BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED +#define BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/next_prior.hpp,v $ +// $Date: 2004/09/17 06:09:38 $ +// $Revision: 1.3 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_COMMON_NAME_WKND(next) +BOOST_MPL_AUX_COMMON_NAME_WKND(prior) + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct next +{ + typedef typename T::next type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,next,(T)) +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct prior +{ + typedef typename T::prior type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,prior,(T)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, next) +BOOST_MPL_AUX_NA_SPEC(1, prior) + +}} + +#endif // BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/not.hpp b/deal.II/contrib/boost/include/boost/mpl/not.hpp new file mode 100644 index 0000000000..9a51fc50f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/not.hpp @@ -0,0 +1,51 @@ + +#ifndef BOOST_MPL_NOT_HPP_INCLUDED +#define BOOST_MPL_NOT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/not.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(long, C_) > // 'long' is intentional here +struct not_impl + : bool_ +{ +}; + +} // namespace aux + + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct not_ + : aux::not_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T)::value + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,not_,(T)) +}; + +BOOST_MPL_AUX_NA_SPEC(1,not_) + +}} + +#endif // BOOST_MPL_NOT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/not_equal_to.hpp b/deal.II/contrib/boost/include/boost/mpl/not_equal_to.hpp new file mode 100644 index 0000000000..74787e1a1e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/not_equal_to.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED +#define BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/not_equal_to.hpp,v $ +// $Date: 2004/09/02 15:40:41 $ +// $Revision: 1.3 $ + +#define AUX778076_OP_NAME not_equal_to +#define AUX778076_OP_TOKEN != +#include + +#endif // BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/numeric_cast.hpp b/deal.II/contrib/boost/include/boost/mpl/numeric_cast.hpp new file mode 100644 index 0000000000..106a2d0432 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/numeric_cast.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED +#define BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/numeric_cast.hpp,v $ +// $Date: 2005/06/26 17:14:04 $ +// $Revision: 1.9 $ + +#include +#include + +// agurt 21/sep/04: portability macro for the sake of MSVC 6.x-7.0; +// resolves conflicts with 'boost::numeric_cast' function template. +// use it in your own code _only_ if you care about compatibility with +// these outdated compilers! +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570) ) +# define BOOST_MPL_AUX_NUMERIC_CAST numeric_cast_ +#else +# define BOOST_MPL_AUX_NUMERIC_CAST numeric_cast +#endif + +namespace boost { namespace mpl { + +// no default implementation; the definition is needed to make MSVC happy + +template< typename SourceTag, typename TargetTag > struct BOOST_MPL_AUX_NUMERIC_CAST +{ + template< typename N > struct apply; +}; + +}} + +#endif // BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/or.hpp b/deal.II/contrib/boost/include/boost/mpl/or.hpp new file mode 100644 index 0000000000..7ab97ff8b5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/or.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_OR_HPP_INCLUDED +#define BOOST_MPL_OR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/or.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# include +# include +# include +# include +# include + +// agurt, 19/may/04: workaround a conflict with header's +// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)' +// has to be checked in a separate condition, otherwise GCC complains +// about 'or' being an alternative token +#if defined(_MSC_VER) +#if defined(or) +# pragma push_macro("or") +# undef or +# define or(x) +#endif +#endif + +# define BOOST_MPL_PREPROCESSED_HEADER or.hpp +# include + +#if defined(_MSC_VER) +#if defined(or) +# pragma pop_macro("or") +#endif +#endif + +#else + +# define AUX778076_OP_NAME or_ +# define AUX778076_OP_VALUE1 true +# define AUX778076_OP_VALUE2 false +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_OR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/order.hpp b/deal.II/contrib/boost/include/boost/mpl/order.hpp new file mode 100644 index 0000000000..23a5fb61b0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/order.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_ORDER_HPP_INCLUDED +#define BOOST_MPL_ORDER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/order.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) + , typename BOOST_MPL_AUX_NA_PARAM(Key) + > +struct order + : order_impl< typename sequence_tag::type > + ::template apply +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,order,(AssociativeSequence,Key)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, order) + +}} + +#endif // BOOST_MPL_ORDER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/order_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/order_fwd.hpp new file mode 100644 index 0000000000..ecaa285ffa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/order_fwd.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_ORDER_FWD_HPP_INCLUDED +#define BOOST_MPL_ORDER_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/order_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.3 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct order_impl; +template< typename AssociativeSequence, typename Key > struct order; + +}} + +#endif // BOOST_MPL_ORDER_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/pair.hpp b/deal.II/contrib/boost/include/boost/mpl/pair.hpp new file mode 100644 index 0000000000..8a9a47331a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/pair.hpp @@ -0,0 +1,70 @@ + +#ifndef BOOST_MPL_PAIR_HPP_INCLUDED +#define BOOST_MPL_PAIR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/pair.hpp,v $ +// $Date: 2004/12/14 14:05:31 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct pair +{ + typedef pair type; + typedef T1 first; + typedef T2 second; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,pair,(T1,T2)) +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(P) + > +struct first +{ +#if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) + typedef typename P::first type; +#else + typedef typename aux::msvc_eti_base

::first type; +#endif + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,first,(P)) +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(P) + > +struct second +{ +#if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) + typedef typename P::second type; +#else + typedef typename aux::msvc_eti_base

::second type; +#endif + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,second,(P)) +}; + + +BOOST_MPL_AUX_NA_SPEC_NO_ETI(2, pair) +BOOST_MPL_AUX_NA_SPEC(1, first) +BOOST_MPL_AUX_NA_SPEC(1, second) + +}} + +#endif // BOOST_MPL_PAIR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/pair_view.hpp b/deal.II/contrib/boost/include/boost/mpl/pair_view.hpp new file mode 100644 index 0000000000..04bea087ca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/pair_view.hpp @@ -0,0 +1,169 @@ + +#ifndef BOOST_MPL_PAIR_VIEW_HPP_INCLUDED +#define BOOST_MPL_PAIR_VIEW_HPP_INCLUDED + +// Copyright David Abrahams 2003-2004 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/pair_view.hpp,v $ +// $Date: 2004/11/28 01:56:21 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { +struct pair_iter_tag; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename Iter1, typename Iter2, typename Category > +struct pair_iter; + +template< typename Category > struct prior_pair_iter +{ + template< typename Iter1, typename Iter2 > struct apply + { + typedef typename mpl::prior::type i1_; + typedef typename mpl::prior::type i2_; + typedef pair_iter type; + }; +}; + +template<> struct prior_pair_iter +{ + template< typename Iter1, typename Iter2 > struct apply + { + typedef pair_iter type; + }; +}; + +#endif +} + +template< + typename Iter1 + , typename Iter2 + , typename Category + > +struct pair_iter +{ + typedef aux::pair_iter_tag tag; + typedef Category category; + typedef Iter1 first; + typedef Iter2 second; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + typedef pair< + typename deref::type + , typename deref::type + > type; + + typedef typename mpl::next::type i1_; + typedef typename mpl::next::type i2_; + typedef pair_iter next; + + typedef apply_wrap2< aux::prior_pair_iter,Iter1,Iter2 >::type prior; +#endif +}; + + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename Iter1, typename Iter2, typename C > +struct deref< pair_iter > +{ + typedef pair< + typename deref::type + , typename deref::type + > type; +}; + +template< typename Iter1, typename Iter2, typename C > +struct next< pair_iter > +{ + typedef typename mpl::next::type i1_; + typedef typename mpl::next::type i2_; + typedef pair_iter type; +}; + +template< typename Iter1, typename Iter2, typename C > +struct prior< pair_iter > +{ + typedef typename mpl::prior::type i1_; + typedef typename mpl::prior::type i2_; + typedef pair_iter type; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + +template<> struct advance_impl +{ + template< typename Iter, typename D > struct apply + { + typedef typename mpl::advance< typename Iter::first,D >::type i1_; + typedef typename mpl::advance< typename Iter::second,D >::type i2_; + typedef pair_iter type; + }; +}; + +template<> struct distance_impl +{ + template< typename Iter1, typename Iter2 > struct apply + { + // agurt, 10/nov/04: MSVC 6.5 ICE-s on forwarding + typedef typename mpl::distance< + typename first::type + , typename first::type + >::type type; + }; +}; + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence1) + , typename BOOST_MPL_AUX_NA_PARAM(Sequence2) + > +struct pair_view +{ + typedef nested_begin_end_tag tag; + + typedef typename begin::type iter1_; + typedef typename begin::type iter2_; + typedef typename min< + typename iterator_category::type + , typename iterator_category::type + >::type category_; + + typedef pair_iter begin; + + typedef pair_iter< + typename end::type + , typename end::type + , category_ + > end; +}; + +BOOST_MPL_AUX_NA_SPEC(2, pair_view) + +}} + +#endif // BOOST_MPL_PAIR_VIEW_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/partition.hpp b/deal.II/contrib/boost/include/boost/mpl/partition.hpp new file mode 100644 index 0000000000..264b68725c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/partition.hpp @@ -0,0 +1,53 @@ + +#ifndef BOOST_MPL_PARTITION_HPP_INCLUDED +#define BOOST_MPL_PARTITION_HPP_INCLUDED + +// Copyright Eric Friedman 2002-2003 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/partition.hpp,v $ +// $Date: 2004/11/28 01:56:21 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template < + typename Sequence + , typename Pred + , typename In1 + , typename In2 + > +struct partition_impl + : stable_partition_impl +{ +}; + +template < + typename Sequence + , typename Pred + , typename In1 + , typename In2 + > +struct reverse_partition_impl + : reverse_stable_partition_impl +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, partition) + +}} + +#endif // BOOST_MPL_PARTITION_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/placeholders.hpp b/deal.II/contrib/boost/include/boost/mpl/placeholders.hpp new file mode 100644 index 0000000000..f12f5a8531 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/placeholders.hpp @@ -0,0 +1,100 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED +#define BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/placeholders.hpp,v $ +// $Date: 2004/09/16 14:08:46 $ +// $Revision: 1.4 $ + + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include + +# if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) +# define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) \ + using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; \ + /**/ +# else +# define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) /**/ +# endif + +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER placeholders.hpp +# include + +#else + +# include +# include +# include +# include + +// watch out for GNU gettext users, who #define _(x) +#if !defined(_) || defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<-1> _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} +#endif + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY + 1, )) +#include BOOST_PP_ITERATE() + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +typedef arg BOOST_PP_CAT(_,i_); + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(BOOST_PP_CAT(_,i_)) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::BOOST_PP_CAT(_,i_); +} + +}} + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/plus.hpp b/deal.II/contrib/boost/include/boost/mpl/plus.hpp new file mode 100644 index 0000000000..fefe79aacb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/plus.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_PLUS_HPP_INCLUDED +#define BOOST_MPL_PLUS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/plus.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#define AUX778076_OP_NAME plus +#define AUX778076_OP_TOKEN + +#include + +#endif // BOOST_MPL_PLUS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/pop_back.hpp b/deal.II/contrib/boost/include/boost/mpl/pop_back.hpp new file mode 100644 index 0000000000..61173d486d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/pop_back.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_POP_BACK_HPP_INCLUDED +#define BOOST_MPL_POP_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/pop_back.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct pop_back + : pop_back_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,pop_back,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, pop_back) + +}} + +#endif // BOOST_MPL_POP_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/pop_back_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/pop_back_fwd.hpp new file mode 100644 index 0000000000..f776842c2f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/pop_back_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED +#define BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/pop_back_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct pop_back_impl; +template< typename Sequence > struct pop_back; + +}} + +#endif // BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/pop_front.hpp b/deal.II/contrib/boost/include/boost/mpl/pop_front.hpp new file mode 100644 index 0000000000..871d5e18de --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/pop_front.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_POP_FRONT_HPP_INCLUDED +#define BOOST_MPL_POP_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/pop_front.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct pop_front + : pop_front_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,pop_front,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, pop_front) + +}} + +#endif // BOOST_MPL_POP_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/pop_front_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/pop_front_fwd.hpp new file mode 100644 index 0000000000..0d0ef38d1a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/pop_front_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED +#define BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/pop_front_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct pop_front_impl; +template< typename Sequence > struct pop_front; + +}} + +#endif // BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/print.hpp b/deal.II/contrib/boost/include/boost/mpl/print.hpp new file mode 100755 index 0000000000..a1974826ee --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/print.hpp @@ -0,0 +1,74 @@ + +#ifndef BOOST_MPL_PRINT_HPP_INCLUDED +#define BOOST_MPL_PRINT_HPP_INCLUDED + +// Copyright David Abrahams 2003 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/print.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +namespace aux { +#if defined(BOOST_MSVC) +# pragma warning(push, 3) +// we only want one warning from MSVC, so turn off the other one +# pragma warning(disable: 4307) +#elif defined(__MWERKS__) +# pragma warn_hidevirtual on + struct print_base { virtual void f() {} }; +#endif + +#if defined(__EDG_VERSION__) + template + struct dependent_unsigned + { + static const unsigned value = 1; + }; +#endif +} // namespace aux + + +template +struct print + : mpl::identity +#if defined(__MWERKS__) + , aux::print_base +#endif +{ +#if defined(BOOST_MSVC) + enum { n = sizeof(T) + -1 }; +#elif defined(__MWERKS__) + void f(int); +#else + enum { + n = +# if defined(__EDG_VERSION__) + aux::dependent_unsigned::value > -1 +# else + sizeof(T) > -1, +# endif + }; +#endif +}; + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#elif defined(__MWERKS__) +# pragma warn_hidevirtual reset +#endif + +}} + +#endif // BOOST_MPL_PRINT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/prior.hpp b/deal.II/contrib/boost/include/boost/mpl/prior.hpp new file mode 100644 index 0000000000..376cc275f9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/prior.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_PRIOR_HPP_INCLUDED +#define BOOST_MPL_PRIOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/prior.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.7 $ + +#include + +#endif // BOOST_MPL_PRIOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/protect.hpp b/deal.II/contrib/boost/include/boost/mpl/protect.hpp new file mode 100644 index 0000000000..6a87fea689 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/protect.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_PROTECT_HPP_INCLUDED +#define BOOST_MPL_PROTECT_HPP_INCLUDED + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/protect.hpp,v $ +// $Date: 2004/09/07 21:37:24 $ +// $Revision: 1.10 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + , int not_le_ = 0 + > +struct protect : T +{ +#if BOOST_WORKAROUND(__EDG_VERSION__, == 238) + typedef mpl::protect type; +#else + typedef protect type; +#endif +}; + +#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +namespace aux { +template< BOOST_MPL_AUX_NTTP_DECL(int, N), typename T > +struct arity< protect, N > + : arity +{ +}; +} // namespace aux +#endif + +BOOST_MPL_AUX_NA_SPEC_MAIN(1, protect) +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(1, 1, protect) +#endif + +}} + +#endif // BOOST_MPL_PROTECT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/push_back.hpp b/deal.II/contrib/boost/include/boost/mpl/push_back.hpp new file mode 100644 index 0000000000..8b17541205 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/push_back.hpp @@ -0,0 +1,53 @@ + +#ifndef BOOST_MPL_PUSH_BACK_HPP_INCLUDED +#define BOOST_MPL_PUSH_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/push_back.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct push_back + : push_back_impl< typename sequence_tag::type > + ::template apply< Sequence,T > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,push_back,(Sequence,T)) +}; + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct has_push_back + : has_push_back_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,has_push_back,(Sequence)) +}; + + +BOOST_MPL_AUX_NA_SPEC(2, push_back) +BOOST_MPL_AUX_NA_SPEC(1, has_push_back) + +}} + +#endif // BOOST_MPL_PUSH_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/push_back_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/push_back_fwd.hpp new file mode 100644 index 0000000000..2701ce1406 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/push_back_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED +#define BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/push_back_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct push_back_impl; +template< typename Sequence, typename T > struct push_back; + +}} + +#endif // BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/push_front.hpp b/deal.II/contrib/boost/include/boost/mpl/push_front.hpp new file mode 100644 index 0000000000..a9a02f9306 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/push_front.hpp @@ -0,0 +1,52 @@ + +#ifndef BOOST_MPL_PUSH_FRONT_HPP_INCLUDED +#define BOOST_MPL_PUSH_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/push_front.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct push_front + : push_front_impl< typename sequence_tag::type > + ::template apply< Sequence,T > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,push_front,(Sequence,T)) +}; + + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct has_push_front + : has_push_front_impl< typename sequence_tag::type > + ::template apply< Sequence > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,has_push_front,(Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, push_front) +BOOST_MPL_AUX_NA_SPEC(1, has_push_front) + +}} + +#endif // BOOST_MPL_PUSH_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/push_front_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/push_front_fwd.hpp new file mode 100644 index 0000000000..155480a236 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/push_front_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED +#define BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/push_front_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct push_front_impl; +template< typename Sequence, typename T > struct push_front; + +}} + +#endif // BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/quote.hpp b/deal.II/contrib/boost/include/boost/mpl/quote.hpp new file mode 100644 index 0000000000..f2e8976366 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/quote.hpp @@ -0,0 +1,130 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_QUOTE_HPP_INCLUDED +#define BOOST_MPL_QUOTE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/quote.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.5 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) +# define BOOST_MPL_CFG_NO_QUOTE_TEMPLATE +#endif + +#if !defined(BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS) \ + && defined(BOOST_MPL_CFG_NO_HAS_XXX) +# define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER quote.hpp +# include + +#else + +# include +# include +# include +# include + +# include +# include + +#if !defined(BOOST_MPL_CFG_NO_QUOTE_TEMPLATE) + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename T, bool has_type_ > +struct quote_impl + : T +{ +}; + +template< typename T > +struct quote_impl +{ + typedef T type; +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template< bool > struct quote_impl +{ + template< typename T > struct result_ + : T + { + }; +}; + +template<> struct quote_impl +{ + template< typename T > struct result_ + { + typedef T type; + }; +}; + +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_QUOTE_TEMPLATE + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_QUOTE_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + template< BOOST_MPL_PP_PARAMS(i_, typename P) > class F + , typename Tag = void_ + > +struct BOOST_PP_CAT(quote,i_) +{ + template< BOOST_MPL_PP_PARAMS(i_, typename U) > struct apply +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + : quote_impl< + F< BOOST_MPL_PP_PARAMS(i_, U) > + , aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value + > +#else + : quote_impl< aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value > + ::template result_< F< BOOST_MPL_PP_PARAMS(i_, U) > > +#endif + { + }; +}; + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/range_c.hpp b/deal.II/contrib/boost/include/boost/mpl/range_c.hpp new file mode 100644 index 0000000000..4a969bdd2a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/range_c.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_RANGE_C_HPP_INCLUDED +#define BOOST_MPL_RANGE_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/range_c.hpp,v $ +// $Date: 2004/11/28 01:57:09 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename T + , T Start + , T Finish + > +struct range_c +{ + typedef aux::half_open_range_tag tag; + typedef T value_type; + typedef range_c type; + + typedef integral_c start; + typedef integral_c finish; + + typedef r_iter begin; + typedef r_iter end; +}; + +}} + +#endif // BOOST_MPL_RANGE_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/remove.hpp b/deal.II/contrib/boost/include/boost/mpl/remove.hpp new file mode 100644 index 0000000000..2345da1e01 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/remove.hpp @@ -0,0 +1,52 @@ + +#ifndef BOOST_MPL_REMOVE_HPP_INCLUDED +#define BOOST_MPL_REMOVE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/remove.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.5 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Sequence + , typename T + , typename Inserter + > +struct remove_impl + : remove_if_impl< Sequence, same_as, Inserter > +{ +}; + +template< + typename Sequence + , typename T + , typename Inserter + > +struct reverse_remove_impl + : reverse_remove_if_impl< Sequence, same_as, Inserter > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, remove) + +}} + +#endif // BOOST_MPL_REMOVE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/remove_if.hpp b/deal.II/contrib/boost/include/boost/mpl/remove_if.hpp new file mode 100644 index 0000000000..25d0c1c042 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/remove_if.hpp @@ -0,0 +1,83 @@ + +#ifndef BOOST_MPL_REMOVE_IF_HPP_INCLUDED +#define BOOST_MPL_REMOVE_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/remove_if.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< typename Pred, typename InsertOp > struct remove_if_helper +{ + template< typename Sequence, typename U > struct apply + { + typedef typename eval_if< + typename apply1::type + , identity + , apply2 + >::type type; + }; +}; + +template< + typename Sequence + , typename Predicate + , typename Inserter + > +struct remove_if_impl + : fold< + Sequence + , typename Inserter::state + , protect< aux::remove_if_helper< + typename lambda::type + , typename Inserter::operation + > > + > +{ +}; + +template< + typename Sequence + , typename Predicate + , typename Inserter + > +struct reverse_remove_if_impl + : reverse_fold< + Sequence + , typename Inserter::state + , protect< aux::remove_if_helper< + typename lambda::type + , typename Inserter::operation + > > + > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, remove_if) + +}} + +#endif // BOOST_MPL_REMOVE_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/replace.hpp b/deal.II/contrib/boost/include/boost/mpl/replace.hpp new file mode 100644 index 0000000000..50992b06ec --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/replace.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_REPLACE_HPP_INCLUDED +#define BOOST_MPL_REPLACE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright John R. Bandela 2000-2002 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/replace.hpp,v $ +// $Date: 2004/11/28 01:57:09 $ +// $Revision: 1.8 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Sequence + , typename OldType + , typename NewType + , typename Inserter + > +struct replace_impl + : replace_if_impl< Sequence, same_as, NewType, Inserter > +{ +}; + +template< + typename Sequence + , typename OldType + , typename NewType + , typename Inserter + > +struct reverse_replace_impl + : reverse_replace_if_impl< Sequence, same_as, NewType, Inserter > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, replace) + +}} + +#endif // BOOST_MPL_REPLACE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/replace_if.hpp b/deal.II/contrib/boost/include/boost/mpl/replace_if.hpp new file mode 100644 index 0000000000..a5a5668c66 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/replace_if.hpp @@ -0,0 +1,88 @@ + +#ifndef BOOST_MPL_REPLACE_IF_HPP_INCLUDED +#define BOOST_MPL_REPLACE_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright John R. Bandela 2000-2002 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/replace_if.hpp,v $ +// $Date: 2004/11/28 01:57:09 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< typename Predicate, typename T > +struct replace_if_op +{ + template< typename U > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : if_< + typename apply1::type + , T + , U + > + { +#else + { + typedef typename if_< + typename apply1::type + , T + , U + >::type type; +#endif + }; +}; + + +template< + typename Sequence + , typename Predicate + , typename T + , typename Inserter + > +struct replace_if_impl + : transform1_impl< + Sequence + , protect< aux::replace_if_op > + , Inserter + > +{ +}; + +template< + typename Sequence + , typename Predicate + , typename T + , typename Inserter + > +struct reverse_replace_if_impl + : reverse_transform1_impl< + Sequence + , protect< aux::replace_if_op > + , Inserter + > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, replace_if) + +}} + +#endif // BOOST_MPL_REPLACE_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/reverse.hpp b/deal.II/contrib/boost/include/boost/mpl/reverse.hpp new file mode 100644 index 0000000000..83fee4e169 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/reverse.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_REVERSE_HPP_INCLUDED +#define BOOST_MPL_REVERSE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/reverse.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.5 $ + +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(Inserter) + > +struct reverse + : reverse_copy< + Sequence + , Inserter + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC(1, reverse) + +}} + +#endif // BOOST_MPL_REVERSE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/reverse_fold.hpp b/deal.II/contrib/boost/include/boost/mpl/reverse_fold.hpp new file mode 100644 index 0000000000..12259038fb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/reverse_fold.hpp @@ -0,0 +1,50 @@ + +#ifndef BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED +#define BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright David Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/reverse_fold.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(State) + , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp) + , typename ForwardOp = arg<1> + > +struct reverse_fold +{ + typedef typename aux::reverse_fold_impl< + ::boost::mpl::O1_size::value + , typename begin::type + , typename end::type + , State + , BackwardOp + , ForwardOp + >::state type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,reverse_fold,(Sequence,State,BackwardOp)) +}; + +BOOST_MPL_AUX_NA_SPEC(3, reverse_fold) + +}} + +#endif // BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/reverse_iter_fold.hpp b/deal.II/contrib/boost/include/boost/mpl/reverse_iter_fold.hpp new file mode 100644 index 0000000000..3aa7f2881d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/reverse_iter_fold.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_ITER_FOLD_BACKWARD_HPP_INCLUDED +#define BOOST_MPL_ITER_FOLD_BACKWARD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Dave Abrahams 2001-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/reverse_iter_fold.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(State) + , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp) + , typename ForwardOp = arg<1> + > +struct reverse_iter_fold +{ + typedef typename aux::reverse_iter_fold_impl< + ::boost::mpl::O1_size::value + , typename begin::type + , typename end::type + , State + , typename lambda::type + , typename lambda::type + >::state type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT( + 4 + , reverse_iter_fold + , (Sequence,State,BackwardOp,ForwardOp) + ) +}; + +BOOST_MPL_AUX_NA_SPEC(3, reverse_iter_fold) + +}} + +#endif // BOOST_MPL_ITER_FOLD_BACKWARD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/same_as.hpp b/deal.II/contrib/boost/include/boost/mpl/same_as.hpp new file mode 100644 index 0000000000..28f882cb06 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/same_as.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_SAME_AS_HPP_INCLUDED +#define BOOST_MPL_SAME_AS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/same_as.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.6 $ + +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +template< typename T1 > +struct same_as +{ + template< typename T2 > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : is_same + { +#else + { + typedef typename is_same::type type; +#endif + }; +}; + +template< typename T1 > +struct not_same_as +{ + template< typename T2 > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) + : not_< is_same > + { +#else + { + typedef typename not_< is_same >::type type; +#endif + }; +}; + +}} + +#endif // BOOST_MPL_SAME_AS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/sequence_tag.hpp b/deal.II/contrib/boost/include/boost/mpl/sequence_tag.hpp new file mode 100644 index 0000000000..f4e891304d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/sequence_tag.hpp @@ -0,0 +1,124 @@ + +#ifndef BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED +#define BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/sequence_tag.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// agurt, 27/nov/02: have to use a simplistic 'sequence_tag' implementation +// on MSVC to avoid dreadful "internal structure overflow" error +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \ + || defined(BOOST_MPL_CFG_NO_HAS_XXX) + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct sequence_tag +{ + typedef typename Sequence::tag type; +}; + +#elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) + +// agurt, 07/feb/03: workaround for what seems to be MSVC 7.0-specific ETI issue + +namespace aux { + +template< bool > +struct sequence_tag_impl +{ + template< typename Sequence > struct result_ + { + typedef typename Sequence::tag type; + }; +}; + +template<> +struct sequence_tag_impl +{ + template< typename Sequence > struct result_ + { + typedef int type; + }; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct sequence_tag + : aux::sequence_tag_impl< !aux::is_msvc_eti_arg::value > + ::template result_ +{ +}; + +#else + +namespace aux { + +template< bool has_tag_, bool has_begin_ > +struct sequence_tag_impl +{ + // agurt 24/nov/02: MSVC 6.5 gets confused in 'sequence_tag_impl' + // specialization below, if we name it 'result_' here + template< typename Sequence > struct result2_; +}; + +# define AUX_CLASS_SEQUENCE_TAG_SPEC(has_tag, has_begin, result_type) \ +template<> struct sequence_tag_impl \ +{ \ + template< typename Sequence > struct result2_ \ + { \ + typedef result_type type; \ + }; \ +}; \ +/**/ + +AUX_CLASS_SEQUENCE_TAG_SPEC(true, true, typename Sequence::tag) +AUX_CLASS_SEQUENCE_TAG_SPEC(true, false, typename Sequence::tag) +AUX_CLASS_SEQUENCE_TAG_SPEC(false, true, nested_begin_end_tag) +AUX_CLASS_SEQUENCE_TAG_SPEC(false, false, non_sequence_tag) + +# undef AUX_CLASS_SEQUENCE_TAG_SPEC + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct sequence_tag + : aux::sequence_tag_impl< + ::boost::mpl::aux::has_tag::value + , ::boost::mpl::aux::has_begin::value + >::template result2_ +{ +}; + +#endif // BOOST_MSVC + +BOOST_MPL_AUX_NA_SPEC(1, sequence_tag) + +}} + +#endif // BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/sequence_tag_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/sequence_tag_fwd.hpp new file mode 100644 index 0000000000..a9dd7776e3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/sequence_tag_fwd.hpp @@ -0,0 +1,26 @@ + +#ifndef BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED +#define BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/sequence_tag_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.3 $ + +namespace boost { namespace mpl { + +struct nested_begin_end_tag; +struct non_sequence_tag; + +template< typename Sequence > struct sequence_tag; + +}} + +#endif // BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set.hpp b/deal.II/contrib/boost/include/boost/mpl/set.hpp new file mode 100644 index 0000000000..61749a261f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_SET_HPP_INCLUDED +#define BOOST_MPL_SET_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_SET_HEADER \ + BOOST_PP_CAT(set, BOOST_MPL_LIMIT_SET_SIZE).hpp \ + /**/ +#else +# define AUX778076_SET_HEADER \ + BOOST_PP_CAT(set, BOOST_MPL_LIMIT_SET_SIZE)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_HEADER) +# undef AUX778076_SET_HEADER +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME set +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_SET_SIZE +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_SET_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/at_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/at_impl.hpp new file mode 100644 index 0000000000..d5120d44c1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/at_impl.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/at_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct at_impl< aux::set_tag > +{ + template< typename Set, typename T > struct apply + { + typedef typename if_< + has_key_impl::apply + , T + , void_ + >::type type; + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/begin_end_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/begin_end_impl.hpp new file mode 100644 index 0000000000..e9647a4e4f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/begin_end_impl.hpp @@ -0,0 +1,43 @@ + +#ifndef BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/begin_end_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.3 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct begin_impl< aux::set_tag > +{ + template< typename Set > struct apply + { + typedef s_iter type; + }; +}; + +template<> +struct end_impl< aux::set_tag > +{ + template< typename Set > struct apply + { + typedef s_iter< Set,set0<> > type; + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/clear_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/clear_impl.hpp new file mode 100644 index 0000000000..20fd4fe41a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/clear_impl.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/clear_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct clear_impl< aux::set_tag > +{ + template< typename Set > struct apply + { + typedef set0<> type; + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/empty_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/empty_impl.hpp new file mode 100644 index 0000000000..622390b493 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/empty_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/empty_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct empty_impl< aux::set_tag > +{ + template< typename Set > struct apply + : not_< typename Set::size > + { + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/erase_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/erase_impl.hpp new file mode 100644 index 0000000000..d74c41a5a3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/erase_impl.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/erase_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct erase_impl< aux::set_tag > +{ + template< + typename Set + , typename Pos + , typename unused_ + > + struct apply + : erase_key_impl + ::apply + { + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp new file mode 100644 index 0000000000..fd448bb074 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp @@ -0,0 +1,53 @@ + +#ifndef BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/erase_key_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +template<> +struct erase_key_impl< aux::set_tag > +{ + template< + typename Set + , typename T + > + struct apply + : eval_if< + has_key_impl::apply + , eval_if< + is_same< T,typename Set::item_type_ > + , base + , identity< s_mask > + > + , identity + > + { + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/has_key_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/has_key_impl.hpp new file mode 100644 index 0000000000..55aaa25cd3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/has_key_impl.hpp @@ -0,0 +1,60 @@ + +#ifndef BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/has_key_impl.hpp,v $ +// $Date: 2004/10/13 18:23:37 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template<> +struct has_key_impl< aux::set_tag > +{ + template< typename Set, typename T > struct apply +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) + { + BOOST_STATIC_CONSTANT(bool, value = + ( sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED( + Set + , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) + ) ) == sizeof(aux::no_tag) ) + ); + + typedef bool_ type; + +#else // ISO98 C++ + : bool_< + ( sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED( + Set + , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) + ) ) == sizeof(aux::no_tag) ) + > + { +#endif + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/include_preprocessed.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/include_preprocessed.hpp new file mode 100644 index 0000000000..2bb73ecec7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/include_preprocessed.hpp @@ -0,0 +1,36 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/include_preprocessed.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include + +#include +#include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_HEADER \ + plain/BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#else +# define AUX778076_HEADER \ + BOOST_PP_CAT(plain,/)##BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#endif + + +# include BOOST_PP_STRINGIZE(boost/mpl/set/aux_/preprocessed/AUX778076_HEADER) + +# undef AUX778076_HEADER + +#undef BOOST_MPL_PREPROCESSED_HEADER diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/insert_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/insert_impl.hpp new file mode 100644 index 0000000000..64ac317273 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/insert_impl.hpp @@ -0,0 +1,65 @@ + +#ifndef BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/insert_impl.hpp,v $ +// $Date: 2004/09/05 09:42:59 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +namespace aux { +template< typename Set, typename T > struct set_insert_impl + : eval_if< + has_key_impl::apply + , identity + , eval_if< + is_same< T,typename Set::last_masked_ > + , base + , identity< s_item > + > + > +{ +}; +} + +template<> +struct insert_impl< aux::set_tag > +{ + template< + typename Set + , typename PosOrKey + , typename KeyOrNA + > + struct apply + : aux::set_insert_impl< + Set + , typename if_na::type + > + { + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/item.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/item.hpp new file mode 100644 index 0000000000..5a66be4016 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/item.hpp @@ -0,0 +1,82 @@ + +#ifndef BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/item.hpp,v $ +// $Date: 2005/06/18 22:03:09 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename T, typename Base > +struct s_item + : Base +{ + typedef s_item item_; + typedef void_ last_masked_; + typedef Base next_; + typedef T item_type_; + typedef item_type_ type; + typedef Base base; + + typedef typename next< typename Base::size >::type size; + typedef typename next< typename Base::order >::type order; + +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) + typedef typename aux::weighted_tag::type order_tag_; +#else + typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value]; +#endif + + BOOST_MPL_AUX_SET_OVERLOAD( order_tag_, ORDER_BY_KEY, s_item, aux::type_wrapper* ); + BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_item, aux::type_wrapper* ); +}; + + +template< typename T, typename Base > +struct s_mask + : Base +{ + typedef s_mask item_; + typedef T last_masked_; + typedef void_ item_type_; + typedef Base base; + typedef typename prior< typename Base::size >::type size; + + BOOST_MPL_AUX_SET_OVERLOAD( aux::yes_tag, IS_MASKED, s_mask, aux::type_wrapper* ); +}; + + +template< typename T, typename Base > +struct s_unmask + : Base +{ + typedef s_unmask item_; + typedef void_ last_masked_; + typedef T item_type_; + typedef Base base; + typedef typename next< typename Base::size >::type size; + + BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_unmask, aux::type_wrapper* ); +}; + +}} + +#endif // BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/iterator.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/iterator.hpp new file mode 100644 index 0000000000..cb1c9482ce --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/iterator.hpp @@ -0,0 +1,97 @@ + +#ifndef BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/iterator.hpp,v $ +// $Date: 2005/06/18 22:03:09 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +// used by 's_iter_impl' +template< typename Set, typename Tail > struct s_iter; + +template< typename Set, typename Tail > struct s_iter_impl +{ + typedef Tail tail_; + typedef forward_iterator_tag category; + typedef typename Tail::item_::type type; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + typedef typename eval_if< + has_key< Set,typename Tail::next_::type > + , identity< s_iter > + , next< s_iter > + >::type next; +#endif +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename Set, typename Tail > +struct next< s_iter > + : eval_if< + has_key< Set,typename Tail::next_::type > + , identity< s_iter > + , next< s_iter > + > +{ +}; + +template< typename Set > +struct next< s_iter > > +{ + typedef s_iter > type; +}; + +template< typename Set, typename Tail > struct s_iter + : s_iter_impl +{ +}; + +template< typename Set > struct s_iter > +{ + typedef forward_iterator_tag category; +}; + +#else + +template< typename Set > +struct s_end_iter +{ + typedef forward_iterator_tag category; + typedef s_iter > next; +}; + +template< typename Set, typename Tail > struct s_iter + : if_< + is_same< Tail,set0<> > + , s_end_iter + , s_iter_impl + >::type +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +}} + +#endif // BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/key_type_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/key_type_impl.hpp new file mode 100644 index 0000000000..2810169bc7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/key_type_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/key_type_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct key_type_impl< aux::set_tag > +{ + template< typename Set, typename T > struct apply + { + typedef T type; + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/numbered.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/numbered.hpp new file mode 100644 index 0000000000..45b158d41e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/numbered.hpp @@ -0,0 +1,48 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/numbered.hpp,v $ +// $Date: 2005/06/18 22:03:09 $ +// $Revision: 1.4 $ + +#include +#include +#include + +#define i_ BOOST_PP_FRAME_ITERATION(1) + +# define AUX778076_SET_TAIL(set, i_, T) \ + typename BOOST_PP_CAT(set,i_)< \ + BOOST_PP_ENUM_PARAMS(i_, T) \ + >::item_ \ + /**/ + +#if i_ > 0 +template< + BOOST_PP_ENUM_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(set,i_) + : s_item< + BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) + , AUX778076_SET_TAIL(set,BOOST_PP_DEC(i_),T) + > +{ + typedef BOOST_PP_CAT(set,i_) type; +}; +#endif + +# undef AUX778076_SET_TAIL + +#undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/numbered_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/numbered_c.hpp new file mode 100644 index 0000000000..4bf85d1f5a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/numbered_c.hpp @@ -0,0 +1,48 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/numbered_c.hpp,v $ +// $Date: 2004/11/28 01:50:43 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include + +#define i_ BOOST_PP_FRAME_ITERATION(1) + +# define AUX778076_SET_C_TAIL(set, i_, T, C) \ + BOOST_PP_CAT(BOOST_PP_CAT(set,i_),_c)< \ + T BOOST_PP_ENUM_TRAILING_PARAMS(i_, C) \ + > \ + /**/ + +template< + typename T + , BOOST_PP_ENUM_PARAMS(i_, T C) + > +struct BOOST_PP_CAT(BOOST_PP_CAT(set,i_),_c) + : s_item< + integral_c + , AUX778076_SET_C_TAIL(set,BOOST_PP_DEC(i_), T, C) + > +{ + typedef BOOST_PP_CAT(BOOST_PP_CAT(set,i_),_c) type; +}; + +# undef AUX778076_SET_C_TAIL + +#undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set10.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set10.hpp new file mode 100644 index 0000000000..2c42b38398 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set10.hpp @@ -0,0 +1,140 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 + > +struct set1 + : s_item< + T0 + , typename set0< >::item_ + > +{ + typedef set1 type; +}; + +template< + typename T0, typename T1 + > +struct set2 + : s_item< + T1 + , typename set1::item_ + > +{ + typedef set2 type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct set3 + : s_item< + T2 + , typename set2< T0,T1 >::item_ + > +{ + typedef set3 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct set4 + : s_item< + T3 + , typename set3< T0,T1,T2 >::item_ + > +{ + typedef set4 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct set5 + : s_item< + T4 + , typename set4< T0,T1,T2,T3 >::item_ + > +{ + typedef set5 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct set6 + : s_item< + T5 + , typename set5< T0,T1,T2,T3,T4 >::item_ + > +{ + typedef set6 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct set7 + : s_item< + T6 + , typename set6< T0,T1,T2,T3,T4,T5 >::item_ + > +{ + typedef set7 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct set8 + : s_item< + T7 + , typename set7< T0,T1,T2,T3,T4,T5,T6 >::item_ + > +{ + typedef set8 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct set9 + : s_item< + T8 + , typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::item_ + > +{ + typedef set9 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct set10 + : s_item< + T9 + , typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::item_ + > +{ + typedef set10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp new file mode 100644 index 0000000000..e9bdb29eb8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp @@ -0,0 +1,145 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set10_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0 + > +struct set1_c + : s_item< + integral_c< T,C0 > + , set0_c + > +{ + typedef set1_c type; +}; + +template< + typename T + , T C0, T C1 + > +struct set2_c + : s_item< + integral_c< T,C1 > + , set1_c< T,C0 > + > +{ + typedef set2_c type; +}; + +template< + typename T + , T C0, T C1, T C2 + > +struct set3_c + : s_item< + integral_c< T,C2 > + , set2_c< T,C0,C1 > + > +{ + typedef set3_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3 + > +struct set4_c + : s_item< + integral_c< T,C3 > + , set3_c< T,C0,C1,C2 > + > +{ + typedef set4_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4 + > +struct set5_c + : s_item< + integral_c< T,C4 > + , set4_c< T,C0,C1,C2,C3 > + > +{ + typedef set5_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5 + > +struct set6_c + : s_item< + integral_c< T,C5 > + , set5_c< T,C0,C1,C2,C3,C4 > + > +{ + typedef set6_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6 + > +struct set7_c + : s_item< + integral_c< T,C6 > + , set6_c< T,C0,C1,C2,C3,C4,C5 > + > +{ + typedef set7_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 + > +struct set8_c + : s_item< + integral_c< T,C7 > + , set7_c< T,C0,C1,C2,C3,C4,C5,C6 > + > +{ + typedef set8_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 + > +struct set9_c + : s_item< + integral_c< T,C8 > + , set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > + > +{ + typedef set9_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 + > +struct set10_c + : s_item< + integral_c< T,C9 > + , set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > + > +{ + typedef set10_c type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set20.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set20.hpp new file mode 100644 index 0000000000..cb4e466688 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set20.hpp @@ -0,0 +1,168 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct set11 + : s_item< + T10 + , typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::item_ + > +{ + typedef set11 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct set12 + : s_item< + T11 + , typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::item_ + > +{ + typedef set12 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct set13 + : s_item< + T12 + , typename set12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 + , T11 >::item_ + > +{ + typedef set13 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct set14 + : s_item< + T13 + , typename set13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12 >::item_ + > +{ + typedef set14 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct set15 + : s_item< + T14 + , typename set14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13 >::item_ + > +{ + typedef set15 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct set16 + : s_item< + T15 + , typename set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14 >::item_ + > +{ + typedef set16 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct set17 + : s_item< + T16 + , typename set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15 >::item_ + > +{ + typedef set17 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct set18 + : s_item< + T17 + , typename set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16 >::item_ + > +{ + typedef set18 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct set19 + : s_item< + T18 + , typename set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17 >::item_ + > +{ + typedef set19 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct set20 + : s_item< + T19 + , typename set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18 >::item_ + > +{ + typedef set20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp new file mode 100644 index 0000000000..445b5467ca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp @@ -0,0 +1,154 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set20_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + > +struct set11_c + : s_item< + integral_c< T,C10 > + , set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > + > +{ + typedef set11_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11 + > +struct set12_c + : s_item< + integral_c< T,C11 > + , set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > + > +{ + typedef set12_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12 + > +struct set13_c + : s_item< + integral_c< T,C12 > + , set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > + > +{ + typedef set13_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13 + > +struct set14_c + : s_item< + integral_c< T,C13 > + , set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > + > +{ + typedef set14_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14 + > +struct set15_c + : s_item< + integral_c< T,C14 > + , set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 > + > +{ + typedef set15_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15 + > +struct set16_c + : s_item< + integral_c< T,C15 > + , set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 > + > +{ + typedef set16_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16 + > +struct set17_c + : s_item< + integral_c< T,C16 > + , set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 > + > +{ + typedef set17_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17 + > +struct set18_c + : s_item< + integral_c< T,C17 > + , set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 > + > +{ + typedef set18_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 + > +struct set19_c + : s_item< + integral_c< T,C18 > + , set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 > + > +{ + typedef set19_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 + > +struct set20_c + : s_item< + integral_c< T,C19 > + , set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 > + > +{ + typedef set20_c type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set30.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set30.hpp new file mode 100644 index 0000000000..08f2cda27a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set30.hpp @@ -0,0 +1,195 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20 + > +struct set21 + : s_item< + T20 + , typename set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19 >::item_ + > +{ + typedef set21 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21 + > +struct set22 + : s_item< + T21 + , typename set21< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20 >::item_ + > +{ + typedef set22 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22 + > +struct set23 + : s_item< + T22 + , typename set22< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 >::item_ + > +{ + typedef set23 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23 + > +struct set24 + : s_item< + T23 + , typename set23< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 >::item_ + > +{ + typedef set24 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + > +struct set25 + : s_item< + T24 + , typename set24< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 >::item_ + > +{ + typedef set25 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25 + > +struct set26 + : s_item< + T25 + , typename set25< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 + , T24 >::item_ + > +{ + typedef set26 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26 + > +struct set27 + : s_item< + T26 + , typename set26< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 + , T25 >::item_ + > +{ + typedef set27 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27 + > +struct set28 + : s_item< + T27 + , typename set27< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26 >::item_ + > +{ + typedef set28 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28 + > +struct set29 + : s_item< + T28 + , typename set28< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27 >::item_ + > +{ + typedef set29 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + > +struct set30 + : s_item< + T29 + , typename set29< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28 >::item_ + > +{ + typedef set30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp new file mode 100644 index 0000000000..7c0150ca39 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp @@ -0,0 +1,164 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set30_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + > +struct set21_c + : s_item< + integral_c< T,C20 > + , set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 > + > +{ + typedef set21_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21 + > +struct set22_c + : s_item< + integral_c< T,C21 > + , set21_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 > + > +{ + typedef set22_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22 + > +struct set23_c + : s_item< + integral_c< T,C22 > + , set22_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 > + > +{ + typedef set23_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23 + > +struct set24_c + : s_item< + integral_c< T,C23 > + , set23_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 > + > +{ + typedef set24_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24 + > +struct set25_c + : s_item< + integral_c< T,C24 > + , set24_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 > + > +{ + typedef set25_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25 + > +struct set26_c + : s_item< + integral_c< T,C25 > + , set25_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 > + > +{ + typedef set26_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26 + > +struct set27_c + : s_item< + integral_c< T,C26 > + , set26_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 > + > +{ + typedef set27_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27 + > +struct set28_c + : s_item< + integral_c< T,C27 > + , set27_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 > + > +{ + typedef set28_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 + > +struct set29_c + : s_item< + integral_c< T,C28 > + , set28_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 > + > +{ + typedef set29_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 + > +struct set30_c + : s_item< + integral_c< T,C29 > + , set29_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 > + > +{ + typedef set30_c type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set40.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set40.hpp new file mode 100644 index 0000000000..a8571a61fe --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set40.hpp @@ -0,0 +1,221 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30 + > +struct set31 + : s_item< + T30 + , typename set30< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29 >::item_ + > +{ + typedef set31 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31 + > +struct set32 + : s_item< + T31 + , typename set31< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30 >::item_ + > +{ + typedef set32 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32 + > +struct set33 + : s_item< + T32 + , typename set32< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31 >::item_ + > +{ + typedef set33 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33 + > +struct set34 + : s_item< + T33 + , typename set33< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32 >::item_ + > +{ + typedef set34 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + > +struct set35 + : s_item< + T34 + , typename set34< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33 >::item_ + > +{ + typedef set35 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35 + > +struct set36 + : s_item< + T35 + , typename set35< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34 >::item_ + > +{ + typedef set36 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36 + > +struct set37 + : s_item< + T36 + , typename set36< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35 >::item_ + > +{ + typedef set37 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37 + > +struct set38 + : s_item< + T37 + , typename set37< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36 >::item_ + > +{ + typedef set38 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38 + > +struct set39 + : s_item< + T38 + , typename set38< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37 >::item_ + > +{ + typedef set39 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + > +struct set40 + : s_item< + T39 + , typename set39< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37 + , T38 >::item_ + > +{ + typedef set40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp new file mode 100644 index 0000000000..0b0e49cdd9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp @@ -0,0 +1,174 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set40_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + > +struct set31_c + : s_item< + integral_c< T,C30 > + , set30_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29 > + > +{ + typedef set31_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31 + > +struct set32_c + : s_item< + integral_c< T,C31 > + , set31_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30 > + > +{ + typedef set32_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32 + > +struct set33_c + : s_item< + integral_c< T,C32 > + , set32_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31 > + > +{ + typedef set33_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33 + > +struct set34_c + : s_item< + integral_c< T,C33 > + , set33_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32 > + > +{ + typedef set34_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34 + > +struct set35_c + : s_item< + integral_c< T,C34 > + , set34_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33 > + > +{ + typedef set35_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35 + > +struct set36_c + : s_item< + integral_c< T,C35 > + , set35_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34 > + > +{ + typedef set36_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36 + > +struct set37_c + : s_item< + integral_c< T,C36 > + , set36_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35 > + > +{ + typedef set37_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37 + > +struct set38_c + : s_item< + integral_c< T,C37 > + , set37_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36 > + > +{ + typedef set38_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 + > +struct set39_c + : s_item< + integral_c< T,C38 > + , set38_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37 > + > +{ + typedef set39_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 + > +struct set40_c + : s_item< + integral_c< T,C39 > + , set39_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38 > + > +{ + typedef set40_c type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set50.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set50.hpp new file mode 100644 index 0000000000..79798ab49c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set50.hpp @@ -0,0 +1,250 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40 + > +struct set41 + : s_item< + T40 + , typename set40< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38 + , T39 >::item_ + > +{ + typedef set41 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41 + > +struct set42 + : s_item< + T41 + , typename set41< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40 >::item_ + > +{ + typedef set42 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42 + > +struct set43 + : s_item< + T42 + , typename set42< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41 >::item_ + > +{ + typedef set43 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43 + > +struct set44 + : s_item< + T43 + , typename set43< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42 >::item_ + > +{ + typedef set44 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + > +struct set45 + : s_item< + T44 + , typename set44< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42, T43 >::item_ + > +{ + typedef set45 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45 + > +struct set46 + : s_item< + T45 + , typename set45< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42, T43, T44 >::item_ + > +{ + typedef set46 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46 + > +struct set47 + : s_item< + T46 + , typename set46< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42, T43, T44, T45 >::item_ + > +{ + typedef set47 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47 + > +struct set48 + : s_item< + T47 + , typename set47< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42, T43, T44, T45, T46 >::item_ + > +{ + typedef set48 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48 + > +struct set49 + : s_item< + T48 + , typename set48< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42, T43, T44, T45, T46, T47 >::item_ + > +{ + typedef set49 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48, typename T49 + > +struct set50 + : s_item< + T49 + , typename set49< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 + , T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25 + , T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39 + , T40, T41, T42, T43, T44, T45, T46, T47, T48 >::item_ + > +{ + typedef set50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp new file mode 100644 index 0000000000..83627fa13d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp @@ -0,0 +1,184 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/set/set50_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + > +struct set41_c + : s_item< + integral_c< T,C40 > + , set40_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39 > + > +{ + typedef set41_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41 + > +struct set42_c + : s_item< + integral_c< T,C41 > + , set41_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40 > + > +{ + typedef set42_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42 + > +struct set43_c + : s_item< + integral_c< T,C42 > + , set42_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41 > + > +{ + typedef set43_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43 + > +struct set44_c + : s_item< + integral_c< T,C43 > + , set43_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42 > + > +{ + typedef set44_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44 + > +struct set45_c + : s_item< + integral_c< T,C44 > + , set44_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43 > + > +{ + typedef set45_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45 + > +struct set46_c + : s_item< + integral_c< T,C45 > + , set45_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44 > + > +{ + typedef set46_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46 + > +struct set47_c + : s_item< + integral_c< T,C46 > + , set46_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45 > + > +{ + typedef set47_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47 + > +struct set48_c + : s_item< + integral_c< T,C47 > + , set47_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46 > + > +{ + typedef set48_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 + > +struct set49_c + : s_item< + integral_c< T,C48 > + , set48_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47 > + > +{ + typedef set49_c type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 + > +struct set50_c + : s_item< + integral_c< T,C49 > + , set49_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48 > + > +{ + typedef set50_c type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/set0.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/set0.hpp new file mode 100644 index 0000000000..617d0990af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/set0.hpp @@ -0,0 +1,69 @@ + +#ifndef BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/set0.hpp,v $ +// $Date: 2005/06/18 22:03:08 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) + +# define BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \ + friend R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ +/**/ + +# define BOOST_MPL_AUX_SET_OVERLOAD(R, f, X, T) \ + BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \ +/**/ + +#else + +# define BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \ + static R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ +/**/ + +# define BOOST_MPL_AUX_SET_OVERLOAD(R, f, X, T) \ + BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T); \ + using Base::BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f) \ +/**/ + +#endif + +template< typename Dummy = na > struct set0 +{ + typedef set0<> item_; + typedef aux::set_tag tag; + typedef void_ last_masked_; + typedef void_ item_type_; + typedef item_type_ type; + typedef long_<0> size; + typedef long_<1> order; + + BOOST_MPL_AUX_SET0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, set0<>, void const volatile* ); + BOOST_MPL_AUX_SET0_OVERLOAD( aux::yes_tag, IS_MASKED, set0<>, void const volatile* ); +}; + +}} + +#endif // BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/size_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/size_impl.hpp new file mode 100644 index 0000000000..ff2dd4fb78 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/size_impl.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/size_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct size_impl< aux::set_tag > +{ + template< typename Set > struct apply + : Set::size + { + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/tag.hpp new file mode 100644 index 0000000000..6aedcb26f0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/tag.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/tag.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.3 $ + +namespace boost { namespace mpl { namespace aux { + +struct set_tag; + +}}} + +#endif // BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/aux_/value_type_impl.hpp b/deal.II/contrib/boost/include/boost/mpl/set/aux_/value_type_impl.hpp new file mode 100755 index 0000000000..a02d85e686 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/aux_/value_type_impl.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED +#define BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/aux_/value_type_impl.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template<> +struct value_type_impl< aux::set_tag > +{ + template< typename Set, typename T > struct apply + { + typedef T type; + }; +}; + +}} + +#endif // BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set0.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set0.hpp new file mode 100644 index 0000000000..52f2b992c7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set0.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_SET_SET0_HPP_INCLUDED +#define BOOST_MPL_SET_SET0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set0.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.5 $ + +#include +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_MPL_SET_SET0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set0_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set0_c.hpp new file mode 100644 index 0000000000..4602e7d074 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set0_c.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_SET_SET0_C_HPP_INCLUDED +#define BOOST_MPL_SET_SET0_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set0_c.hpp,v $ +// $Date: 2004/11/28 01:51:10 $ +// $Revision: 1.2 $ + +#include +#include + +namespace boost { namespace mpl { + +template< typename T > struct set0_c + : set0<> +{ + typedef set0_c type; + typedef T value_type; +}; + +}} + +#endif // BOOST_MPL_SET_SET0_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set10.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set10.hpp new file mode 100644 index 0000000000..acb513545d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set10.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_SET_SET10_HPP_INCLUDED +#define BOOST_MPL_SET_SET10_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set10.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set10.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET10_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set10_c.hpp new file mode 100644 index 0000000000..02af4b9c2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set10_c.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_SET_SET10_C_HPP_INCLUDED +#define BOOST_MPL_SET_SET10_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set10_c.hpp,v $ +// $Date: 2004/11/28 01:51:10 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set10_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET10_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set20.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set20.hpp new file mode 100644 index 0000000000..0003ca9aeb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set20.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_SET_SET20_HPP_INCLUDED +#define BOOST_MPL_SET_SET20_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set20.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set20.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET20_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set20_c.hpp new file mode 100644 index 0000000000..9f5f64adb6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set20_c.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_SET_SET20_C_HPP_INCLUDED +#define BOOST_MPL_SET_SET20_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set20_c.hpp,v $ +// $Date: 2004/11/28 01:51:10 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set20_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET20_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set30.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set30.hpp new file mode 100644 index 0000000000..66745a204e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set30.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_SET_SET30_HPP_INCLUDED +#define BOOST_MPL_SET_SET30_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set30.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set30.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET30_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set30_c.hpp new file mode 100644 index 0000000000..f4b2ccf3d8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set30_c.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_SET_SET30_C_HPP_INCLUDED +#define BOOST_MPL_SET_SET30_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set30_c.hpp,v $ +// $Date: 2004/11/28 01:51:10 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set30_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET30_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set40.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set40.hpp new file mode 100644 index 0000000000..110f639e1c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set40.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_SET_SET40_HPP_INCLUDED +#define BOOST_MPL_SET_SET40_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set40.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set40.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET40_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set40_c.hpp new file mode 100644 index 0000000000..b42c62b018 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set40_c.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_SET_SET40_C_HPP_INCLUDED +#define BOOST_MPL_SET_SET40_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set40_c.hpp,v $ +// $Date: 2004/11/28 01:51:10 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set40_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET40_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set50.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set50.hpp new file mode 100644 index 0000000000..9e953f1909 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set50.hpp @@ -0,0 +1,44 @@ + +#ifndef BOOST_MPL_SET_SET50_HPP_INCLUDED +#define BOOST_MPL_SET_SET50_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set50.hpp,v $ +// $Date: 2004/09/02 15:41:02 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set50.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET50_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set/set50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set/set50_c.hpp new file mode 100644 index 0000000000..c856cd2039 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set/set50_c.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_SET_SET50_C_HPP_INCLUDED +#define BOOST_MPL_SET_SET50_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set/set50_c.hpp,v $ +// $Date: 2004/11/28 01:51:10 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set50_c.hpp +# include + +#else + +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_SET_SET50_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/set_c.hpp b/deal.II/contrib/boost/include/boost/mpl/set_c.hpp new file mode 100644 index 0000000000..c27002901c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/set_c.hpp @@ -0,0 +1,60 @@ + +#ifndef BOOST_MPL_SET_C_HPP_INCLUDED +#define BOOST_MPL_SET_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/set_c.hpp,v $ +// $Date: 2004/11/28 01:58:03 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_SET_C_HEADER \ + BOOST_PP_CAT(BOOST_PP_CAT(set,BOOST_MPL_LIMIT_SET_SIZE),_c).hpp \ + /**/ +#else +# define AUX778076_SET_C_HEADER \ + BOOST_PP_CAT(BOOST_PP_CAT(set,BOOST_MPL_LIMIT_SET_SIZE),_c)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_C_HEADER) +# undef AUX778076_SET_C_HEADER +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER set_c.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME set_c +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_SET_SIZE +# define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(set,n),_c) +# define AUX778076_SEQUENCE_INTEGRAL_WRAPPER +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_SET_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/shift_left.hpp b/deal.II/contrib/boost/include/boost/mpl/shift_left.hpp new file mode 100644 index 0000000000..ac38e9d334 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/shift_left.hpp @@ -0,0 +1,22 @@ + +#ifndef BOOST_MPL_SHIFT_LEFT_HPP_INCLUDED +#define BOOST_MPL_SHIFT_LEFT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/shift_left.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#define AUX778076_OP_NAME shift_left +#define AUX778076_OP_TOKEN << +#include + +#endif // BOOST_MPL_SHIFT_LEFT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/shift_right.hpp b/deal.II/contrib/boost/include/boost/mpl/shift_right.hpp new file mode 100644 index 0000000000..26a7ef4e0e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/shift_right.hpp @@ -0,0 +1,22 @@ + +#ifndef BOOST_MPL_SHIFT_RIGHT_HPP_INCLUDED +#define BOOST_MPL_SHIFT_RIGHT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Jaap Suter 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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/shift_right.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#define AUX778076_OP_NAME shift_right +#define AUX778076_OP_TOKEN >> +#include + +#endif // BOOST_MPL_SHIFT_RIGHT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/single_view.hpp b/deal.II/contrib/boost/include/boost/mpl/single_view.hpp new file mode 100644 index 0000000000..e9bb990d37 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/single_view.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_SINGLE_VIEW_HPP_INCLUDED +#define BOOST_MPL_SINGLE_VIEW_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/single_view.hpp,v $ +// $Date: 2004/11/28 01:58:03 $ +// $Revision: 1.4 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct single_view + : iterator_range< + aux::sel_iter + , aux::sel_iter + > +{ +}; + +BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, single_view) + +}} + +#endif // BOOST_MPL_SINGLE_VIEW_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/size.hpp b/deal.II/contrib/boost/include/boost/mpl/size.hpp new file mode 100644 index 0000000000..3a01f013c1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/size.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_SIZE_HPP_INCLUDED +#define BOOST_MPL_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/size.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + > +struct size + : aux::msvc_eti_base< + typename size_impl< typename sequence_tag::type > + ::template apply< Sequence >::type + >::type +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, size, (Sequence)) +}; + +BOOST_MPL_AUX_NA_SPEC(1, size) + +}} + +#endif // BOOST_MPL_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/size_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/size_fwd.hpp new file mode 100644 index 0000000000..53a999bd23 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/size_fwd.hpp @@ -0,0 +1,24 @@ + +#ifndef BOOST_MPL_SIZE_FWD_HPP_INCLUDED +#define BOOST_MPL_SIZE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/size_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct size_impl; +template< typename Sequence > struct size; + +}} + +#endif // BOOST_MPL_SIZE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/size_t.hpp b/deal.II/contrib/boost/include/boost/mpl/size_t.hpp index 231694562b..de76fcaa0f 100644 --- a/deal.II/contrib/boost/include/boost/mpl/size_t.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/size_t.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/size_t.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp index 3ea74dce40..51344ebc22 100644 --- a/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/size_t_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/sizeof.hpp b/deal.II/contrib/boost/include/boost/mpl/sizeof.hpp new file mode 100644 index 0000000000..8b89d6ce7b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/sizeof.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_SIZEOF_HPP_INCLUDED +#define BOOST_MPL_SIZEOF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-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/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/sizeof.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.4 $ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct sizeof_ + : mpl::size_t< sizeof(T) > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,sizeof_,(T)) +}; + +BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, sizeof_) + +}} + +#endif // BOOST_MPL_SIZEOF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/sort.hpp b/deal.II/contrib/boost/include/boost/mpl/sort.hpp new file mode 100644 index 0000000000..bde4352a9a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/sort.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_SORT_HPP_INCLUDED +#define BOOST_MPL_SORT_HPP_INCLUDED + +// Copyright Eric Friedman 2002-2003 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/sort.hpp,v $ +// $Date: 2004/11/28 01:58:03 $ +// $Revision: 1.4 $ + +#include +#include + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, sort) + +}} + +#endif // BOOST_MPL_SORT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/stable_partition.hpp b/deal.II/contrib/boost/include/boost/mpl/stable_partition.hpp new file mode 100644 index 0000000000..c46faa4369 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/stable_partition.hpp @@ -0,0 +1,75 @@ + +#ifndef BOOST_MPL_STABLE_PARTITION_HPP_INCLUDED +#define BOOST_MPL_STABLE_PARTITION_HPP_INCLUDED + +// Copyright Eric Friedman 2002-2003 +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/stable_partition.hpp,v $ +// $Date: 2004/11/28 01:58:27 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template < + typename Sequence + , typename Pred + , typename In + , typename In2 + , typename In1 = typename if_na::type + > +struct stable_partition_impl + : fold< + Sequence + , pair< typename In1::state, typename In2::state > + , protect< partition_op< + Pred + , typename In1::operation + , typename In2::operation + > > + > +{ +}; + +template < + typename Sequence + , typename Pred + , typename In + , typename In2 + , typename In1 = typename if_na::type + > +struct reverse_stable_partition_impl + : reverse_fold< + Sequence + , pair< typename In1::state, typename In2::state > + , protect< partition_op< + Pred + , typename In1::operation + , typename In2::operation + > > + > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, stable_partition) + +}} + +#endif // BOOST_MPL_STABLE_PARTITION_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/switch.hpp b/deal.II/contrib/boost/include/boost/mpl/switch.hpp new file mode 100644 index 0000000000..5744f35b89 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/switch.hpp @@ -0,0 +1,49 @@ + +#ifndef BOOST_MPL_SWITCH_HPP_INCLUDED +#define BOOST_MPL_SWITCH_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/switch.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Body) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct switch_ +{ + typedef typename find_if< + Body + , apply1< lambda< first<_1> >, T > + >::type iter_; + + typedef typename deref::type pair_; + typedef typename lambda< typename second::type >::type f_; + typedef typename apply1::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,switch_,(Body,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, switch_) + +}} + +#endif // BOOST_MPL_SWITCH_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/tag.hpp new file mode 100644 index 0000000000..c0cf4c191c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/tag.hpp @@ -0,0 +1,52 @@ + +#ifndef BOOST_MPL_TAG_HPP_INCLUDED +#define BOOST_MPL_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/tag.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { +template< typename T > struct tag_impl +{ + typedef typename T::tag type; +}; +} + +template< typename T, typename Default = void_ > struct tag +#if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) + : if_< + aux::has_tag + , aux::tag_impl + , Default + >::type +{ +#else +{ + typedef typename eval_if< + aux::has_tag + , aux::tag_impl + , Default + >::type type; + +#endif +}; + +}} + +#endif // BOOST_MPL_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/times.hpp b/deal.II/contrib/boost/include/boost/mpl/times.hpp new file mode 100644 index 0000000000..9d56d1941c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/times.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_TIMES_HPP_INCLUDED +#define BOOST_MPL_TIMES_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/times.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#define AUX778076_OP_NAME times +#define AUX778076_OP_TOKEN * +#include + +#endif // BOOST_MPL_TIMES_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/transform.hpp b/deal.II/contrib/boost/include/boost/mpl/transform.hpp new file mode 100644 index 0000000000..023a99a373 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/transform.hpp @@ -0,0 +1,145 @@ + +#ifndef BOOST_MPL_TRANSFORM_HPP_INCLUDED +#define BOOST_MPL_TRANSFORM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/transform.hpp,v $ +// $Date: 2004/12/20 17:18:17 $ +// $Revision: 1.10 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< + typename Seq + , typename Op + , typename In + > +struct transform1_impl + : fold< + Seq + , typename In::state + , bind2< typename lambda< typename In::operation >::type + , _1 + , bind1< typename lambda::type, _2> + > + > +{ +}; + +template< + typename Seq + , typename Op + , typename In + > +struct reverse_transform1_impl + : reverse_fold< + Seq + , typename In::state + , bind2< typename lambda< typename In::operation >::type + , _1 + , bind1< typename lambda::type, _2> + > + > +{ +}; + +template< + typename Seq1 + , typename Seq2 + , typename Op + , typename In + > +struct transform2_impl + : fold< + pair_view + , typename In::state + , bind2< typename lambda< typename In::operation >::type + , _1 + , bind2< + typename lambda::type + , bind1,_2> + , bind1,_2> + > + > + > +{ +}; + +template< + typename Seq1 + , typename Seq2 + , typename Op + , typename In + > +struct reverse_transform2_impl + : reverse_fold< + pair_view + , typename In::state + , bind2< typename lambda< typename In::operation >::type + , _1 + , bind2< typename lambda< Op >::type + , bind1,_2> + , bind1,_2> + > + > + > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, transform1) +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, transform2) + +#define AUX778076_TRANSFORM_DEF(name) \ +template< \ + typename BOOST_MPL_AUX_NA_PARAM(Seq1) \ + , typename BOOST_MPL_AUX_NA_PARAM(Seq2OrOperation) \ + , typename BOOST_MPL_AUX_NA_PARAM(OperationOrInserter) \ + , typename BOOST_MPL_AUX_NA_PARAM(Inserter) \ + > \ +struct name \ +{ \ + typedef typename eval_if< \ + or_< \ + is_na \ + , is_lambda_expression< Seq2OrOperation > \ + , not_< is_sequence > \ + > \ + , name##1 \ + , name##2 \ + >::type type; \ +}; \ +BOOST_MPL_AUX_NA_SPEC(4, name) \ +/**/ + +AUX778076_TRANSFORM_DEF(transform) +AUX778076_TRANSFORM_DEF(reverse_transform) + +#undef AUX778076_TRANSFORM_DEF + +}} + +#endif // BOOST_MPL_TRANSFORM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/transform_view.hpp b/deal.II/contrib/boost/include/boost/mpl/transform_view.hpp new file mode 100644 index 0000000000..28cccb0270 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/transform_view.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_TRANSFORM_VIEW_HPP_INCLUDED +#define BOOST_MPL_TRANSFORM_VIEW_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/transform_view.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(F) + > +struct transform_view +{ + private: + typedef typename lambda::type f_; + typedef typename begin::type first_; + typedef typename end::type last_; + + public: + struct tag; + typedef transform_view type; + typedef aux::transform_iter< first_,last_,f_ > begin; + typedef aux::transform_iter< last_,last_,f_ > end; +}; + +BOOST_MPL_AUX_NA_SPEC(2, transform_view) + +}} + +#endif // BOOST_MPL_TRANSFORM_VIEW_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/unique.hpp b/deal.II/contrib/boost/include/boost/mpl/unique.hpp new file mode 100644 index 0000000000..5a01d0df2c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/unique.hpp @@ -0,0 +1,85 @@ + +#ifndef BOOST_MPL_UNIQUE_HPP_INCLUDED +#define BOOST_MPL_UNIQUE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright John R. Bandela 2000-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/unique.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.7 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< typename Predicate, typename Operation > +struct unique_op +{ + template< typename Pair, typename T > struct apply + { + typedef typename Pair::first seq_; + typedef typename Pair::second prior_; + typedef typename eval_if< + and_< is_not_na, apply2 > + , identity + , apply2 + >::type new_seq_; + + typedef pair type; + }; +}; + +template< + typename Sequence + , typename Predicate + , typename Inserter + > +struct unique_impl + : first< typename fold< + Sequence + , pair< typename Inserter::state,na > + , protect< aux::unique_op > + >::type > +{ +}; + +template< + typename Sequence + , typename Predicate + , typename Inserter + > +struct reverse_unique_impl + : first< typename reverse_fold< + Sequence + , pair< typename Inserter::state,na > + , protect< aux::unique_op > + >::type > +{ +}; + +} // namespace aux + +BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, unique) + +}} + +#endif // BOOST_MPL_UNIQUE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/unpack_args.hpp b/deal.II/contrib/boost/include/boost/mpl/unpack_args.hpp new file mode 100644 index 0000000000..85e6bf10f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/unpack_args.hpp @@ -0,0 +1,146 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_UNPACK_ARGS_HPP_INCLUDED +#define BOOST_MPL_UNPACK_ARGS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/unpack_args.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER unpack_args.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header + +# define AUX778076_UNPACK(unused, i, Args) \ + , typename at_c::type \ + /**/ + +# define AUX778076_UNPACKED_ARGS(n, Args) \ + BOOST_MPL_PP_REPEAT(n, AUX778076_UNPACK, Args) \ + /**/ + +namespace aux { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template< int size, typename F, typename Args > +struct unpack_args_impl; +#else +template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl +{ + template< typename F, typename Args > struct apply; +}; +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +} + +template< + typename F + > +struct unpack_args +{ + template< typename Args > struct apply +#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + : aux::unpack_args_impl< size::value,F,Args > +# else + : aux::unpack_args_impl< size::value > + ::template apply< F,Args > +# endif + { +#else // BOOST_MPL_CFG_NO_NESTED_FORWARDING + { + typedef typename aux::unpack_args_impl< + size::value + , F + , Args + >::type type; +#endif + }; +}; + +BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) + +# undef AUX778076_UNPACK +# undef AUX778076_UNPACKED_ARGS + +}} + +#endif // BOOST_MPL_CFG_USE_PREPROCESSED_HEADERS +#endif // BOOST_MPL_UNPACK_ARGS_HPP_INCLUDED + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename F, typename Args > +struct unpack_args_impl + : BOOST_PP_CAT(apply,i_)< + F + AUX778076_UNPACKED_ARGS(i_, Args) + > +{ +}; + +#else + +template<> struct unpack_args_impl +{ + template< typename F, typename Args > struct apply + : BOOST_PP_CAT(apply,i_)< + F + AUX778076_UNPACKED_ARGS(i_, Args) + > + { + }; +}; + +#endif + +# undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/upper_bound.hpp b/deal.II/contrib/boost/include/boost/mpl/upper_bound.hpp new file mode 100644 index 0000000000..95df961ea4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/upper_bound.hpp @@ -0,0 +1,141 @@ + +#ifndef BOOST_MPL_UPPER_BOUND_HPP_INCLUDED +#define BOOST_MPL_UPPER_BOUND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/upper_bound.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include + +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +# define BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL +#endif + +#if !defined(BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +#else +# include +# include +#endif + +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL) + +// agurt 23/oct/02: has a wrong complexity etc., but at least it works; +// feel free to contribute a better implementation! +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + , typename Predicate = less<> + , typename pred_ = typename lambda::type + > +struct upper_bound + : find_if< Sequence, bind2 > +{ +}; + +#else + +namespace aux { + +template< + typename Distance + , typename Predicate + , typename T + , typename DeferredIterator + > +struct upper_bound_step_impl; + +template< + typename Distance + , typename Predicate + , typename T + , typename DeferredIterator + > +struct upper_bound_step +{ + typedef typename eval_if< + Distance + , upper_bound_step_impl + , DeferredIterator + >::type type; +}; + +template< + typename Distance + , typename Predicate + , typename T + , typename DeferredIterator + > +struct upper_bound_step_impl +{ + typedef typename divides< Distance, long_<2> >::type offset_; + typedef typename DeferredIterator::type iter_; + typedef typename advance< iter_,offset_ >::type middle_; + typedef typename apply2< + Predicate + , T + , typename deref::type + >::type cond_; + + typedef typename prior< minus< Distance, offset_ > >::type step_; + typedef upper_bound_step< offset_,Predicate,T,DeferredIterator > step_forward_; + typedef upper_bound_step< step_,Predicate,T,next > step_backward_; + typedef typename eval_if< + cond_ + , step_forward_ + , step_backward_ + >::type type; +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + , typename Predicate = less<> + > +struct upper_bound +{ + private: + typedef typename lambda::type pred_; + typedef typename size::type size_; + + public: + typedef typename aux::upper_bound_step< + size_,pred_,T,begin + >::type type; +}; + +#endif // BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL + +BOOST_MPL_AUX_NA_SPEC(2, upper_bound) + +}} + +#endif // BOOST_MPL_UPPER_BOUND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/value_type.hpp b/deal.II/contrib/boost/include/boost/mpl/value_type.hpp new file mode 100755 index 0000000000..5aa3a54cb9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/value_type.hpp @@ -0,0 +1,42 @@ + +#ifndef BOOST_MPL_VALUE_TYPE_HPP_INCLUDED +#define BOOST_MPL_VALUE_TYPE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/value_type.hpp,v $ +// $Date: 2004/12/14 22:34:44 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) + , typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct value_type + : apply_wrap2< + value_type_impl< typename sequence_tag::type > + , AssociativeSequence, T > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,value_type,(AssociativeSequence,T)) +}; + +BOOST_MPL_AUX_NA_SPEC(2, value_type) + +}} + +#endif // BOOST_MPL_VALUE_TYPE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/value_type_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/value_type_fwd.hpp new file mode 100755 index 0000000000..875a758df5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/value_type_fwd.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_VALUE_TYPE_FWD_HPP_INCLUDED +#define BOOST_MPL_VALUE_TYPE_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// Copyright David Abrahams 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/value_type_fwd.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.2 $ + +namespace boost { namespace mpl { + +template< typename Tag > struct value_type_impl; +template< typename AssociativeSequence, typename T > struct value_type; + +}} + +#endif // BOOST_MPL_VALUE_TYPE_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector.hpp b/deal.II/contrib/boost/include/boost/mpl/vector.hpp new file mode 100644 index 0000000000..56f1c95591 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_VECTOR_HPP_INCLUDED +#define BOOST_MPL_VECTOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector.hpp,v $ +// $Date: 2004/11/28 01:58:27 $ +// $Revision: 1.8 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_VECTOR_HEADER \ + BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE).hpp \ + /**/ +#else +# define AUX778076_VECTOR_HEADER \ + BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_HEADER) +# undef AUX778076_VECTOR_HEADER +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME vector +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_VECTOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/O1_size.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/O1_size.hpp new file mode 100644 index 0000000000..2bc734233a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/O1_size.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/O1_size.hpp,v $ +// $Date: 2004/09/04 01:33:47 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template<> +struct O1_size_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : Vector::size + { + }; +}; + +#else + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< long N > +struct O1_size_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : mpl::long_ + { + }; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/at.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/at.hpp new file mode 100644 index 0000000000..a3276b409d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/at.hpp @@ -0,0 +1,116 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/at.hpp,v $ +// $Date: 2004/12/20 19:35:33 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template< typename Vector, long n_ > +struct v_at_impl +{ + typedef long_< (Vector::lower_bound_::value + n_) > index_; + typedef __typeof__( Vector::item_(index_()) ) type; +}; + + +template< typename Vector, long n_ > +struct v_at + : aux::wrapped_type< typename v_at_impl::type > +{ +}; + +template<> +struct at_impl< aux::vector_tag > +{ + template< typename Vector, typename N > struct apply + : v_at< + Vector + , BOOST_MPL_AUX_VALUE_WKND(N)::value + > + { + }; +}; + +#else + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) + +template< typename Vector, BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at; + +template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > +struct at_impl< aux::vector_tag > +{ + template< typename Vector, typename N > struct apply +#if !defined(__BORLANDC__) + : v_at< + Vector + , BOOST_MPL_AUX_VALUE_WKND(N)::value + > + { +#else + { + typedef typename v_at< + Vector + , BOOST_MPL_AUX_VALUE_WKND(N)::value + >::type type; +#endif + }; +}; + +# else + +namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at_impl +{ + template< typename V > struct result_; +}; + +// to work around ETI, etc. +template<> struct v_at_impl<-1> +{ + template< typename V > struct result_ + { + typedef void_ type; + }; +}; + +} // namespace aux + +template< typename T, BOOST_MPL_AUX_NTTP_DECL(long, n_) > +struct v_at + : aux::v_at_impl::template result_ +{ +}; + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/back.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/back.hpp new file mode 100644 index 0000000000..a067b29634 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/back.hpp @@ -0,0 +1,59 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/back.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template<> +struct back_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : v_at< + Vector + , prior::type::value + > + { + }; +}; + +#else + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< long n_ > +struct back_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/begin_end.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/begin_end.hpp new file mode 100644 index 0000000000..976fa1275a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/begin_end.hpp @@ -0,0 +1,49 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/begin_end.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# include +# include +# include + +namespace boost { namespace mpl { + +template<> +struct begin_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef v_iter type; + }; +}; + +template<> +struct end_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef v_iter type; + }; +}; + +}} + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#endif // BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/clear.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/clear.hpp new file mode 100644 index 0000000000..5c468aea92 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/clear.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/clear.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template<> +struct clear_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +#else + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< long N > +struct clear_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/empty.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/empty.hpp new file mode 100644 index 0000000000..dfb986a913 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/empty.hpp @@ -0,0 +1,68 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/empty.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.5 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template<> +struct empty_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : is_same< + typename Vector::lower_bound_ + , typename Vector::upper_bound_ + > + { + }; +}; + +#else + +template<> +struct empty_impl< aux::vector_tag<0> > +{ + template< typename Vector > struct apply + : true_ + { + }; +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< long N > +struct empty_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/front.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/front.hpp new file mode 100644 index 0000000000..7e54e68ec2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/front.hpp @@ -0,0 +1,56 @@ + +#ifndef BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED +#define BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/front.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template<> +struct front_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : v_at + { + }; +}; + +#else + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > +struct front_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp new file mode 100644 index 0000000000..bbe9fd8689 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp @@ -0,0 +1,48 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/include_preprocessed.hpp,v $ +// $Date: 2004/11/28 01:52:12 $ +// $Revision: 1.4 $ + +#include +#include +#include + +#include +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) +# define AUX778076_INCLUDE_DIR typeof_based +#elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + || defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) +# define AUX778076_INCLUDE_DIR no_ctps +#else +# define AUX778076_INCLUDE_DIR plain +#endif + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_HEADER \ + AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#else +# define AUX778076_HEADER \ + BOOST_PP_CAT(AUX778076_INCLUDE_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#endif + + +# include BOOST_PP_STRINGIZE(boost/mpl/vector/aux_/preprocessed/AUX778076_HEADER) + +# undef AUX778076_HEADER +# undef AUX778076_INCLUDE_DIR + +#undef BOOST_MPL_PREPROCESSED_HEADER diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/item.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/item.hpp new file mode 100644 index 0000000000..84673463f7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/item.hpp @@ -0,0 +1,103 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/item.hpp,v $ +// $Date: 2005/05/15 00:39:04 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template< + typename T + , typename Base + , int at_front = 0 + > +struct v_item + : Base +{ + typedef typename Base::upper_bound_ index_; + typedef typename next::type upper_bound_; + typedef typename next::type size; + typedef Base base; + typedef v_item type; + + // agurt 10/sep/04: MWCW <= 9.3 workaround here and below; the compiler + // breaks if using declaration comes _before_ the new overload + static aux::type_wrapper item_(index_); + using Base::item_; +}; + +template< + typename T + , typename Base + > +struct v_item + : Base +{ + typedef typename prior::type index_; + typedef index_ lower_bound_; + typedef typename next::type size; + typedef Base base; + typedef v_item type; + + static aux::type_wrapper item_(index_); + using Base::item_; +}; + +// "erasure" item +template< + typename Base + , int at_front + > +struct v_mask + : Base +{ + typedef typename prior::type index_; + typedef index_ upper_bound_; + typedef typename prior::type size; + typedef Base base; + typedef v_mask type; + + static aux::type_wrapper item_(index_); + using Base::item_; +}; + +template< + typename Base + > +struct v_mask + : Base +{ + typedef typename Base::lower_bound_ index_; + typedef typename next::type lower_bound_; + typedef typename prior::type size; + typedef Base base; + typedef v_mask type; + + static aux::type_wrapper item_(index_); + using Base::item_; +}; + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/iterator.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/iterator.hpp new file mode 100644 index 0000000000..493048324a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/iterator.hpp @@ -0,0 +1,130 @@ + +#ifndef BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED +#define BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/iterator.hpp,v $ +// $Date: 2004/11/28 01:52:12 $ +// $Revision: 1.11 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename Vector + , BOOST_MPL_AUX_NTTP_DECL(long, n_) + > +struct v_iter +{ + typedef aux::v_iter_tag tag; + typedef random_access_iterator_tag category; + typedef typename v_at::type type; + + typedef Vector vector_; + typedef mpl::long_ pos; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + enum { + next_ = n_ + 1 + , prior_ = n_ - 1 + , pos_ = n_ + }; + + typedef v_iter next; + typedef v_iter prior; +#endif + +}; + + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + typename Vector + , BOOST_MPL_AUX_NTTP_DECL(long, n_) + > +struct next< v_iter > +{ + typedef v_iter type; +}; + +template< + typename Vector + , BOOST_MPL_AUX_NTTP_DECL(long, n_) + > +struct prior< v_iter > +{ + typedef v_iter type; +}; + +template< + typename Vector + , BOOST_MPL_AUX_NTTP_DECL(long, n_) + , typename Distance + > +struct advance< v_iter,Distance> +{ + typedef v_iter< + Vector + , (n_ + BOOST_MPL_AUX_NESTED_VALUE_WKND(long, Distance)) + > type; +}; + +template< + typename Vector + , BOOST_MPL_AUX_NTTP_DECL(long, n_) + , BOOST_MPL_AUX_NTTP_DECL(long, m_) + > +struct distance< v_iter, v_iter > + : mpl::long_<(m_ - n_)> +{ +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template<> struct advance_impl +{ + template< typename Iterator, typename N > struct apply + { + enum { pos_ = Iterator::pos_, n_ = N::value }; + typedef v_iter< + typename Iterator::vector_ + , (pos_ + n_) + > type; + }; +}; + +template<> struct distance_impl +{ + template< typename Iter1, typename Iter2 > struct apply + { + enum { pos1_ = Iter1::pos_, pos2_ = Iter2::pos_ }; + typedef long_<( pos2_ - pos1_ )> type; + BOOST_STATIC_CONSTANT(long, value = ( pos2_ - pos1_ )); + }; +}; + +#endif + +}} + +#endif // BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/numbered.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/numbered.hpp new file mode 100644 index 0000000000..29348e357b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/numbered.hpp @@ -0,0 +1,218 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/numbered.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.8 $ + +#include +#include +#include +#include +#include +#include + +#define i_ BOOST_PP_FRAME_ITERATION(1) + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# define AUX778076_VECTOR_TAIL(vector, i_, T) \ + BOOST_PP_CAT(vector,i_)< \ + BOOST_PP_ENUM_PARAMS(i_, T) \ + > \ + /**/ + +#if i_ > 0 +template< + BOOST_PP_ENUM_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(vector,i_) + : v_item< + BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) + , AUX778076_VECTOR_TAIL(vector,BOOST_PP_DEC(i_),T) + > +{ + typedef BOOST_PP_CAT(vector,i_) type; +}; +#endif + +# undef AUX778076_VECTOR_TAIL + +#else // "brute force" implementation + +# if i_ > 0 + +template< + BOOST_PP_ENUM_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(vector,i_) +{ + typedef aux::vector_tag tag; + typedef BOOST_PP_CAT(vector,i_) type; + +# define AUX778076_VECTOR_ITEM(unused, i_, unused2) \ + typedef BOOST_PP_CAT(T,i_) BOOST_PP_CAT(item,i_); \ + /**/ + + BOOST_PP_REPEAT(i_, AUX778076_VECTOR_ITEM, unused) +# undef AUX778076_VECTOR_ITEM + typedef void_ BOOST_PP_CAT(item,i_); + typedef BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) back; + + // Borland forces us to use 'type' here (instead of the class name) + typedef v_iter begin; + typedef v_iter end; +}; + +template<> +struct push_front_impl< aux::vector_tag > +{ + template< typename Vector, typename T > struct apply + { + typedef BOOST_PP_CAT(vector,i_)< + T + BOOST_PP_COMMA_IF(BOOST_PP_DEC(i_)) + BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item) + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef BOOST_PP_CAT(vector,BOOST_PP_DEC(i_))< + BOOST_PP_ENUM_SHIFTED_PARAMS(i_, typename Vector::item) + > type; + }; +}; + + +template<> +struct push_back_impl< aux::vector_tag > +{ + template< typename Vector, typename T > struct apply + { + typedef BOOST_PP_CAT(vector,i_)< + BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item) + BOOST_PP_COMMA_IF(BOOST_PP_DEC(i_)) + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef BOOST_PP_CAT(vector,BOOST_PP_DEC(i_))< + BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item) + > type; + }; +}; + +# endif // i_ > 0 + +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) + +template< typename V > +struct v_at +{ + typedef typename V::BOOST_PP_CAT(item,i_) type; +}; + +# else + +namespace aux { +template<> struct v_at_impl +{ + template< typename V_ > struct result_ + { + typedef typename V_::BOOST_PP_CAT(item,i_) type; + }; +}; +} + +template<> +struct at_impl< aux::vector_tag > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +#if i_ > 0 +template<> +struct front_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; +#endif + +template<> +struct size_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + : long_ + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag > + : size_impl< aux::vector_tag > +{ +}; + +template<> +struct clear_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/numbered_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/numbered_c.hpp new file mode 100644 index 0000000000..1ed78acd35 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/numbered_c.hpp @@ -0,0 +1,77 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +#if defined(BOOST_PP_IS_ITERATING) + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/numbered_c.hpp,v $ +// $Date: 2004/11/28 01:52:12 $ +// $Revision: 1.6 $ + +#include +#include +#include +#include +#include +#include + +#define i_ BOOST_PP_FRAME_ITERATION(1) + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# define AUX778076_VECTOR_TAIL(vector, i_, C) \ + BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) \ + /**/ + +#if i_ > 0 +template< + typename T + , BOOST_PP_ENUM_PARAMS(i_, T C) + > +struct BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) + : v_item< + integral_c + , AUX778076_VECTOR_TAIL(vector,BOOST_PP_DEC(i_),C) + > +{ + typedef BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) type; + typedef T value_type; +}; +#endif + +# undef AUX778076_VECTOR_TAIL + +#else // "brute force" implementation + +# define AUX778076_VECTOR_C_PARAM_FUNC(unused, i_, param) \ + BOOST_PP_COMMA_IF(i_) \ + integral_c \ + /**/ + +template< + typename T + , BOOST_PP_ENUM_PARAMS(i_, T C) + > +struct BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) + : BOOST_PP_CAT(vector,i_)< BOOST_PP_REPEAT(i_,AUX778076_VECTOR_C_PARAM_FUNC,C) > +{ + typedef BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) type; + typedef T value_type; +}; + +# undef AUX778076_VECTOR_C_PARAM_FUNC + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#undef i_ + +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/pop_back.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/pop_back.hpp new file mode 100644 index 0000000000..ebca776773 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/pop_back.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/pop_back.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# include +# include + +namespace boost { namespace mpl { + +template<> +struct pop_back_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef v_mask type; + }; +}; + +}} + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#endif // BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/pop_front.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/pop_front.hpp new file mode 100644 index 0000000000..25fd86927f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/pop_front.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/pop_front.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# include +# include + +namespace boost { namespace mpl { + +template<> +struct pop_front_impl< aux::vector_tag > +{ + template< typename Vector > struct apply + { + typedef v_mask type; + }; +}; + +}} + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#endif // BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp new file mode 100644 index 0000000000..c79a1ac606 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp @@ -0,0 +1,1528 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { +template<> struct v_at_impl<0> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item0 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<0> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct size_impl< aux::vector_tag<0> > +{ + template< typename Vector > struct apply + : long_<0> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<0> > + : size_impl< aux::vector_tag<0> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<0> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0 + > +struct vector1 +{ + typedef aux::vector_tag<1> tag; + typedef vector1 type; + typedef T0 item0; + typedef void_ item1; + typedef T0 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,1 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<0> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector1< + T + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef vector0< + + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<0> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector1< + + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef vector0< + + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<1> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item1 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<1> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + : long_<1> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<1> > + : size_impl< aux::vector_tag<1> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1 + > +struct vector2 +{ + typedef aux::vector_tag<2> tag; + typedef vector2 type; + typedef T0 item0; + typedef T1 item1; + + + typedef void_ item2; + typedef T1 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,2 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<1> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector2< + T + , + typename Vector::item0 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef vector1< + typename Vector::item1 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<1> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector2< + typename Vector::item0 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef vector1< + typename Vector::item0 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<2> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item2 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<2> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + : long_<2> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<2> > + : size_impl< aux::vector_tag<2> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector3 +{ + typedef aux::vector_tag<3> tag; + typedef vector3 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + + + typedef void_ item3; + typedef T2 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,3 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<2> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector3< + T + , + typename Vector::item0, typename Vector::item1 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef vector2< + typename Vector::item1, typename Vector::item2 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<2> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector3< + typename Vector::item0, typename Vector::item1 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef vector2< + typename Vector::item0, typename Vector::item1 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<3> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item3 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<3> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + : long_<3> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<3> > + : size_impl< aux::vector_tag<3> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector4 +{ + typedef aux::vector_tag<4> tag; + typedef vector4 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + + + typedef void_ item4; + typedef T3 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,4 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<3> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector4< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef vector3< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<3> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector4< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef vector3< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<4> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item4 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<4> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + : long_<4> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<4> > + : size_impl< aux::vector_tag<4> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector5 +{ + typedef aux::vector_tag<5> tag; + typedef vector5 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + + + typedef void_ item5; + typedef T4 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,5 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<4> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector5< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef vector4< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<4> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector5< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef vector4< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<5> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item5 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<5> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + : long_<5> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<5> > + : size_impl< aux::vector_tag<5> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector6 +{ + typedef aux::vector_tag<6> tag; + typedef vector6 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + + + typedef void_ item6; + typedef T5 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,6 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<5> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector6< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef vector5< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<5> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector6< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef vector5< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<6> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item6 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<6> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + : long_<6> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<6> > + : size_impl< aux::vector_tag<6> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector7 +{ + typedef aux::vector_tag<7> tag; + typedef vector7 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + + + typedef void_ item7; + typedef T6 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,7 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<6> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector7< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef vector6< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<6> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector7< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef vector6< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<7> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item7 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<7> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + : long_<7> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<7> > + : size_impl< aux::vector_tag<7> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector8 +{ + typedef aux::vector_tag<8> tag; + typedef vector8 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + + + typedef void_ item8; + typedef T7 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,8 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<7> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector8< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef vector7< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<7> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector8< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef vector7< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<8> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item8 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<8> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + : long_<8> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<8> > + : size_impl< aux::vector_tag<8> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector9 +{ + typedef aux::vector_tag<9> tag; + typedef vector9 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + + + typedef void_ item9; + typedef T8 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,9 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<8> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector9< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef vector8< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<8> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector9< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef vector8< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<9> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item9 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<9> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + : long_<9> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<9> > + : size_impl< aux::vector_tag<9> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector10 +{ + typedef aux::vector_tag<10> tag; + typedef vector10 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + + + typedef void_ item10; + typedef T9 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,10 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<9> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector10< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef vector9< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<9> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector10< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef vector9< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<10> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item10 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<10> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + : long_<10> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<10> > + : size_impl< aux::vector_tag<10> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp new file mode 100644 index 0000000000..8b36f6a3ed --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp @@ -0,0 +1,149 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0 + > +struct vector1_c + : vector1< integral_c< T,C0 > > +{ + typedef vector1_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1 + > +struct vector2_c + : vector2< integral_c< T,C0 >, integral_c< T,C1 > > +{ + typedef vector2_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2 + > +struct vector3_c + : vector3< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > > +{ + typedef vector3_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3 + > +struct vector4_c + : vector4< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >, integral_c + > +{ + typedef vector4_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4 + > +struct vector5_c + : vector5< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 > + > +{ + typedef vector5_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5 + > +struct vector6_c + : vector6< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 > + > +{ + typedef vector6_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6 + > +struct vector7_c + : vector7< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c + > +{ + typedef vector7_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 + > +struct vector8_c + : vector8< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 > + > +{ + typedef vector8_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 + > +struct vector9_c + : vector9< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 > + > +{ + typedef vector9_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 + > +struct vector10_c + : vector10< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + > +{ + typedef vector10_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp new file mode 100644 index 0000000000..eb92a7814c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp @@ -0,0 +1,1804 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector11 +{ + typedef aux::vector_tag<11> tag; + typedef vector11 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + + + typedef void_ item11; + typedef T10 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,11 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<10> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector11< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef vector10< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<10> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector11< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef vector10< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<11> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item11 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<11> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + : long_<11> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<11> > + : size_impl< aux::vector_tag<11> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector12 +{ + typedef aux::vector_tag<12> tag; + typedef vector12 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + + + typedef void_ item12; + typedef T11 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,12 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<11> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector12< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef vector11< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<11> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector12< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef vector11< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<12> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item12 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<12> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + : long_<12> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<12> > + : size_impl< aux::vector_tag<12> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector13 +{ + typedef aux::vector_tag<13> tag; + typedef vector13 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + + + typedef void_ item13; + typedef T12 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,13 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<12> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector13< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef vector12< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<12> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector13< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef vector12< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<13> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item13 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<13> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + : long_<13> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<13> > + : size_impl< aux::vector_tag<13> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector14 +{ + typedef aux::vector_tag<14> tag; + typedef vector14 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + + + typedef void_ item14; + typedef T13 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,14 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<13> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector14< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef vector13< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<13> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector14< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef vector13< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<14> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item14 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<14> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + : long_<14> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<14> > + : size_impl< aux::vector_tag<14> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector15 +{ + typedef aux::vector_tag<15> tag; + typedef vector15 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + + + typedef void_ item15; + typedef T14 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,15 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<14> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector15< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef vector14< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<14> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector15< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef vector14< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<15> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item15 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<15> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + : long_<15> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<15> > + : size_impl< aux::vector_tag<15> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector16 +{ + typedef aux::vector_tag<16> tag; + typedef vector16 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + + + typedef void_ item16; + typedef T15 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,16 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<15> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector16< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef vector15< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<15> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector16< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef vector15< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<16> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item16 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<16> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + : long_<16> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<16> > + : size_impl< aux::vector_tag<16> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector17 +{ + typedef aux::vector_tag<17> tag; + typedef vector17 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + + + typedef void_ item17; + typedef T16 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,17 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<16> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector17< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef vector16< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<16> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector17< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef vector16< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<17> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item17 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<17> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + : long_<17> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<17> > + : size_impl< aux::vector_tag<17> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector18 +{ + typedef aux::vector_tag<18> tag; + typedef vector18 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + + + typedef void_ item18; + typedef T17 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,18 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<17> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector18< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef vector17< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<17> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector18< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef vector17< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<18> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item18 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<18> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + : long_<18> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<18> > + : size_impl< aux::vector_tag<18> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector19 +{ + typedef aux::vector_tag<19> tag; + typedef vector19 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + + + typedef void_ item19; + typedef T18 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,19 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<18> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector19< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef vector18< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<18> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector19< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef vector18< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<19> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item19 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<19> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + : long_<19> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<19> > + : size_impl< aux::vector_tag<19> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector20 +{ + typedef aux::vector_tag<20> tag; + typedef vector20 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + + + typedef void_ item20; + typedef T19 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,20 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<19> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector20< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef vector19< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<19> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector20< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef vector19< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<20> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item20 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<20> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + : long_<20> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<20> > + : size_impl< aux::vector_tag<20> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp new file mode 100644 index 0000000000..56ca53f4ea --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp @@ -0,0 +1,195 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + > +struct vector11_c + : vector11< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >, integral_c + > +{ + typedef vector11_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11 + > +struct vector12_c + : vector12< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 > + > +{ + typedef vector12_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12 + > +struct vector13_c + : vector13< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + > +{ + typedef vector13_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13 + > +struct vector14_c + : vector14< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >, integral_c + > +{ + typedef vector14_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14 + > +struct vector15_c + : vector15< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 > + > +{ + typedef vector15_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15 + > +struct vector16_c + : vector16< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + > +{ + typedef vector16_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16 + > +struct vector17_c + : vector17< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >, integral_c + > +{ + typedef vector17_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17 + > +struct vector18_c + : vector18< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 > + > +{ + typedef vector18_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 + > +struct vector19_c + : vector19< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + > +{ + typedef vector19_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 + > +struct vector20_c + : vector20< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >, integral_c + > +{ + typedef vector20_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp new file mode 100644 index 0000000000..a685019b48 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp @@ -0,0 +1,2124 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20 + > +struct vector21 +{ + typedef aux::vector_tag<21> tag; + typedef vector21 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + + + typedef void_ item21; + typedef T20 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,21 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<20> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector21< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef vector20< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<20> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector21< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef vector20< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<21> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item21 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<21> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + : long_<21> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<21> > + : size_impl< aux::vector_tag<21> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21 + > +struct vector22 +{ + typedef aux::vector_tag<22> tag; + typedef vector22 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + + + typedef void_ item22; + typedef T21 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,22 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<21> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector22< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef vector21< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<21> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector22< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef vector21< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<22> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item22 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<22> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + : long_<22> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<22> > + : size_impl< aux::vector_tag<22> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22 + > +struct vector23 +{ + typedef aux::vector_tag<23> tag; + typedef vector23 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + + + typedef void_ item23; + typedef T22 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,23 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<22> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector23< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef vector22< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<22> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector23< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef vector22< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<23> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item23 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<23> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + : long_<23> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<23> > + : size_impl< aux::vector_tag<23> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23 + > +struct vector24 +{ + typedef aux::vector_tag<24> tag; + typedef vector24 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + + + typedef void_ item24; + typedef T23 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,24 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<23> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector24< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef vector23< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<23> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector24< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef vector23< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<24> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item24 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<24> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + : long_<24> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<24> > + : size_impl< aux::vector_tag<24> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + > +struct vector25 +{ + typedef aux::vector_tag<25> tag; + typedef vector25 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + + + typedef void_ item25; + typedef T24 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,25 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<24> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector25< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef vector24< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<24> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector25< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef vector24< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<25> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item25 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<25> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + : long_<25> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<25> > + : size_impl< aux::vector_tag<25> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25 + > +struct vector26 +{ + typedef aux::vector_tag<26> tag; + typedef vector26 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + + + typedef void_ item26; + typedef T25 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,26 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<25> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector26< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef vector25< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<25> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector26< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef vector25< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<26> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item26 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<26> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + : long_<26> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<26> > + : size_impl< aux::vector_tag<26> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26 + > +struct vector27 +{ + typedef aux::vector_tag<27> tag; + typedef vector27 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + + + typedef void_ item27; + typedef T26 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,27 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<26> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector27< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef vector26< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<26> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector27< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef vector26< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<27> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item27 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<27> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + : long_<27> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<27> > + : size_impl< aux::vector_tag<27> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27 + > +struct vector28 +{ + typedef aux::vector_tag<28> tag; + typedef vector28 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + + + typedef void_ item28; + typedef T27 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,28 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<27> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector28< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef vector27< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<27> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector28< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef vector27< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<28> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item28 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<28> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + : long_<28> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<28> > + : size_impl< aux::vector_tag<28> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28 + > +struct vector29 +{ + typedef aux::vector_tag<29> tag; + typedef vector29 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + + + typedef void_ item29; + typedef T28 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,29 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<28> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector29< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef vector28< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<28> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector29< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef vector28< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<29> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item29 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<29> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + : long_<29> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<29> > + : size_impl< aux::vector_tag<29> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + > +struct vector30 +{ + typedef aux::vector_tag<30> tag; + typedef vector30 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + + + typedef void_ item30; + typedef T29 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,30 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<29> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector30< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef vector29< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<29> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector30< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef vector29< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<30> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item30 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<30> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + : long_<30> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<30> > + : size_impl< aux::vector_tag<30> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp new file mode 100644 index 0000000000..6251dbc546 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp @@ -0,0 +1,238 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + > +struct vector21_c + : vector21< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 > + > +{ + typedef vector21_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21 + > +struct vector22_c + : vector22< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + > +{ + typedef vector22_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22 + > +struct vector23_c + : vector23< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >, integral_c + > +{ + typedef vector23_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23 + > +struct vector24_c + : vector24< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 > + > +{ + typedef vector24_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24 + > +struct vector25_c + : vector25< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + > +{ + typedef vector25_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25 + > +struct vector26_c + : vector26< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >, integral_c + > +{ + typedef vector26_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26 + > +struct vector27_c + : vector27< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 > + > +{ + typedef vector27_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27 + > +struct vector28_c + : vector28< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + > +{ + typedef vector28_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 + > +struct vector29_c + : vector29< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >, integral_c + > +{ + typedef vector29_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 + > +struct vector30_c + : vector30< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 > + > +{ + typedef vector30_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp new file mode 100644 index 0000000000..1ed648a9d0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp @@ -0,0 +1,2444 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30 + > +struct vector31 +{ + typedef aux::vector_tag<31> tag; + typedef vector31 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + + + typedef void_ item31; + typedef T30 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,31 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<30> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector31< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef vector30< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<30> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector31< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef vector30< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<31> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item31 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<31> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + : long_<31> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<31> > + : size_impl< aux::vector_tag<31> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31 + > +struct vector32 +{ + typedef aux::vector_tag<32> tag; + typedef vector32 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + + + typedef void_ item32; + typedef T31 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,32 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<31> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector32< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef vector31< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<31> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector32< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef vector31< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<32> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item32 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<32> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + : long_<32> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<32> > + : size_impl< aux::vector_tag<32> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32 + > +struct vector33 +{ + typedef aux::vector_tag<33> tag; + typedef vector33 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + + + typedef void_ item33; + typedef T32 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,33 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<32> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector33< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef vector32< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<32> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector33< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef vector32< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<33> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item33 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<33> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + : long_<33> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<33> > + : size_impl< aux::vector_tag<33> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33 + > +struct vector34 +{ + typedef aux::vector_tag<34> tag; + typedef vector34 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + + + typedef void_ item34; + typedef T33 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,34 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<33> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector34< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef vector33< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<33> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector34< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef vector33< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<34> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item34 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<34> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + : long_<34> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<34> > + : size_impl< aux::vector_tag<34> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + > +struct vector35 +{ + typedef aux::vector_tag<35> tag; + typedef vector35 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + + + typedef void_ item35; + typedef T34 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,35 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<34> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector35< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef vector34< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<34> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector35< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef vector34< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<35> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item35 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<35> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + : long_<35> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<35> > + : size_impl< aux::vector_tag<35> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35 + > +struct vector36 +{ + typedef aux::vector_tag<36> tag; + typedef vector36 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + + + typedef void_ item36; + typedef T35 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,36 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<35> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector36< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef vector35< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<35> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector36< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef vector35< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<36> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item36 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<36> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + : long_<36> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<36> > + : size_impl< aux::vector_tag<36> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36 + > +struct vector37 +{ + typedef aux::vector_tag<37> tag; + typedef vector37 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + + + typedef void_ item37; + typedef T36 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,37 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<36> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector37< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef vector36< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<36> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector37< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef vector36< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<37> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item37 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<37> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + : long_<37> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<37> > + : size_impl< aux::vector_tag<37> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37 + > +struct vector38 +{ + typedef aux::vector_tag<38> tag; + typedef vector38 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + + + typedef void_ item38; + typedef T37 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,38 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<37> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector38< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef vector37< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<37> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector38< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef vector37< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<38> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item38 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<38> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + : long_<38> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<38> > + : size_impl< aux::vector_tag<38> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38 + > +struct vector39 +{ + typedef aux::vector_tag<39> tag; + typedef vector39 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + + + typedef void_ item39; + typedef T38 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,39 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<38> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector39< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef vector38< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<38> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector39< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef vector38< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<39> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item39 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<39> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + : long_<39> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<39> > + : size_impl< aux::vector_tag<39> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + > +struct vector40 +{ + typedef aux::vector_tag<40> tag; + typedef vector40 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + + + typedef void_ item40; + typedef T39 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,40 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<39> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector40< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef vector39< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<39> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector40< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef vector39< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<40> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item40 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<40> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + : long_<40> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<40> > + : size_impl< aux::vector_tag<40> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp new file mode 100644 index 0000000000..ba0ffa88ee --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp @@ -0,0 +1,281 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + > +struct vector31_c + : vector31< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + > +{ + typedef vector31_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31 + > +struct vector32_c + : vector32< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >, integral_c + > +{ + typedef vector32_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32 + > +struct vector33_c + : vector33< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 > + > +{ + typedef vector33_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33 + > +struct vector34_c + : vector34< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + > +{ + typedef vector34_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34 + > +struct vector35_c + : vector35< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >, integral_c + > +{ + typedef vector35_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35 + > +struct vector36_c + : vector36< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 > + > +{ + typedef vector36_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36 + > +struct vector37_c + : vector37< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + > +{ + typedef vector37_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37 + > +struct vector38_c + : vector38< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >, integral_c + > +{ + typedef vector38_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 + > +struct vector39_c + : vector39< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 > + > +{ + typedef vector39_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 + > +struct vector40_c + : vector40< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + > +{ + typedef vector40_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp new file mode 100644 index 0000000000..3da323a998 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp @@ -0,0 +1,2764 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40 + > +struct vector41 +{ + typedef aux::vector_tag<41> tag; + typedef vector41 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + + + typedef void_ item41; + typedef T40 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,41 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<40> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector41< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef vector40< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<40> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector41< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef vector40< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<41> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item41 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<41> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + : long_<41> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<41> > + : size_impl< aux::vector_tag<41> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41 + > +struct vector42 +{ + typedef aux::vector_tag<42> tag; + typedef vector42 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + + + typedef void_ item42; + typedef T41 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,42 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<41> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector42< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef vector41< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<41> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector42< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef vector41< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<42> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item42 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<42> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + : long_<42> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<42> > + : size_impl< aux::vector_tag<42> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42 + > +struct vector43 +{ + typedef aux::vector_tag<43> tag; + typedef vector43 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + + + typedef void_ item43; + typedef T42 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,43 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<42> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector43< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef vector42< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<42> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector43< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef vector42< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<43> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item43 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<43> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + : long_<43> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<43> > + : size_impl< aux::vector_tag<43> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43 + > +struct vector44 +{ + typedef aux::vector_tag<44> tag; + typedef vector44 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + + + typedef void_ item44; + typedef T43 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,44 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<43> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector44< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef vector43< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<43> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector44< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef vector43< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<44> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item44 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<44> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + : long_<44> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<44> > + : size_impl< aux::vector_tag<44> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + > +struct vector45 +{ + typedef aux::vector_tag<45> tag; + typedef vector45 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + + + typedef void_ item45; + typedef T44 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,45 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<44> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector45< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef vector44< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<44> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector45< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef vector44< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<45> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item45 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<45> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + : long_<45> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<45> > + : size_impl< aux::vector_tag<45> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45 + > +struct vector46 +{ + typedef aux::vector_tag<46> tag; + typedef vector46 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + + + typedef void_ item46; + typedef T45 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,46 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<45> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector46< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef vector45< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<45> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector46< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef vector45< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<46> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item46 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<46> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + : long_<46> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<46> > + : size_impl< aux::vector_tag<46> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46 + > +struct vector47 +{ + typedef aux::vector_tag<47> tag; + typedef vector47 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + + + typedef void_ item47; + typedef T46 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,47 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<46> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector47< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef vector46< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<46> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector47< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef vector46< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<47> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item47 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<47> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + : long_<47> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<47> > + : size_impl< aux::vector_tag<47> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47 + > +struct vector48 +{ + typedef aux::vector_tag<48> tag; + typedef vector48 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + typedef T47 item47; + + + typedef void_ item48; + typedef T47 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,48 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<47> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector48< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef vector47< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + , typename Vector::item47 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<47> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector48< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef vector47< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<48> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item48 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<48> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + : long_<48> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<48> > + : size_impl< aux::vector_tag<48> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48 + > +struct vector49 +{ + typedef aux::vector_tag<49> tag; + typedef vector49 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + typedef T47 item47; + typedef T48 item48; + + + typedef void_ item49; + typedef T48 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,49 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<48> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector49< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef vector48< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + , typename Vector::item47, typename Vector::item48 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<48> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector49< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef vector48< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<49> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item49 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<49> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + : long_<49> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<49> > + : size_impl< aux::vector_tag<49> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48, typename T49 + > +struct vector50 +{ + typedef aux::vector_tag<50> tag; + typedef vector50 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + typedef T47 item47; + typedef T48 item48; + typedef T49 item49; + + + typedef void_ item50; + typedef T49 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,50 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<49> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector50< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , typename Vector::item48 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef vector49< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + , typename Vector::item47, typename Vector::item48 + , typename Vector::item49 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<49> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector50< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , typename Vector::item48 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef vector49< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , typename Vector::item48 + > type; + }; +}; + +namespace aux { +template<> struct v_at_impl<50> +{ + template< typename V_ > struct result_ + { + typedef typename V_::item50 type; + }; +}; + +} + +template<> +struct at_impl< aux::vector_tag<50> > +{ + template< typename V_, typename N > struct apply + { + typedef typename aux::v_at_impl + ::template result_::type type; + }; +}; + +template<> +struct front_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::item0 type; + }; +}; + +template<> +struct back_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef typename Vector::back type; + }; +}; + +template<> +struct empty_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + : false_ + { + }; +}; + +template<> +struct size_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + : long_<50> + { + }; +}; + +template<> +struct O1_size_impl< aux::vector_tag<50> > + : size_impl< aux::vector_tag<50> > +{ +}; + +template<> +struct clear_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef vector0<> type; + }; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp new file mode 100644 index 0000000000..e07f2b3ad5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp @@ -0,0 +1,325 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + > +struct vector41_c + : vector41< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >, integral_c + > +{ + typedef vector41_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41 + > +struct vector42_c + : vector42< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 > + > +{ + typedef vector42_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42 + > +struct vector43_c + : vector43< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + > +{ + typedef vector43_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43 + > +struct vector44_c + : vector44< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >, integral_c + > +{ + typedef vector44_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44 + > +struct vector45_c + : vector45< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 > + > +{ + typedef vector45_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45 + > +struct vector46_c + : vector46< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + > +{ + typedef vector46_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46 + > +struct vector47_c + : vector47< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >, integral_c + > +{ + typedef vector47_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47 + > +struct vector48_c + : vector48< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + , integral_c< T,C46 >, integral_c< T,C47 > + > +{ + typedef vector48_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 + > +struct vector49_c + : vector49< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 > + > +{ + typedef vector49_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 + > +struct vector50_c + : vector50< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >, integral_c + > +{ + typedef vector50_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp new file mode 100644 index 0000000000..88bbd3b318 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp @@ -0,0 +1,829 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename V > +struct v_at< V,0 > +{ + typedef typename V::item0 type; +}; + +template< + typename T0 + > +struct vector1 +{ + typedef aux::vector_tag<1> tag; + typedef vector1 type; + typedef T0 item0; + typedef void_ item1; + typedef T0 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,1 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<0> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector1< + T + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef vector0< + + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<0> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector1< + + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<1> > +{ + template< typename Vector > struct apply + { + typedef vector0< + + > type; + }; +}; + +template< typename V > +struct v_at< V,1 > +{ + typedef typename V::item1 type; +}; + +template< + typename T0, typename T1 + > +struct vector2 +{ + typedef aux::vector_tag<2> tag; + typedef vector2 type; + typedef T0 item0; + typedef T1 item1; + + + typedef void_ item2; + typedef T1 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,2 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<1> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector2< + T + , + typename Vector::item0 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef vector1< + typename Vector::item1 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<1> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector2< + typename Vector::item0 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<2> > +{ + template< typename Vector > struct apply + { + typedef vector1< + typename Vector::item0 + > type; + }; +}; + +template< typename V > +struct v_at< V,2 > +{ + typedef typename V::item2 type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector3 +{ + typedef aux::vector_tag<3> tag; + typedef vector3 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + + + typedef void_ item3; + typedef T2 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,3 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<2> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector3< + T + , + typename Vector::item0, typename Vector::item1 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef vector2< + typename Vector::item1, typename Vector::item2 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<2> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector3< + typename Vector::item0, typename Vector::item1 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<3> > +{ + template< typename Vector > struct apply + { + typedef vector2< + typename Vector::item0, typename Vector::item1 + > type; + }; +}; + +template< typename V > +struct v_at< V,3 > +{ + typedef typename V::item3 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector4 +{ + typedef aux::vector_tag<4> tag; + typedef vector4 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + + + typedef void_ item4; + typedef T3 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,4 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<3> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector4< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef vector3< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<3> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector4< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<4> > +{ + template< typename Vector > struct apply + { + typedef vector3< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2 + > type; + }; +}; + +template< typename V > +struct v_at< V,4 > +{ + typedef typename V::item4 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector5 +{ + typedef aux::vector_tag<5> tag; + typedef vector5 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + + + typedef void_ item5; + typedef T4 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,5 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<4> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector5< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef vector4< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<4> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector5< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<5> > +{ + template< typename Vector > struct apply + { + typedef vector4< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + > type; + }; +}; + +template< typename V > +struct v_at< V,5 > +{ + typedef typename V::item5 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector6 +{ + typedef aux::vector_tag<6> tag; + typedef vector6 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + + + typedef void_ item6; + typedef T5 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,6 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<5> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector6< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef vector5< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<5> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector6< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<6> > +{ + template< typename Vector > struct apply + { + typedef vector5< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4 + > type; + }; +}; + +template< typename V > +struct v_at< V,6 > +{ + typedef typename V::item6 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector7 +{ + typedef aux::vector_tag<7> tag; + typedef vector7 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + + + typedef void_ item7; + typedef T6 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,7 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<6> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector7< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef vector6< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<6> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector7< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<7> > +{ + template< typename Vector > struct apply + { + typedef vector6< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + > type; + }; +}; + +template< typename V > +struct v_at< V,7 > +{ + typedef typename V::item7 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector8 +{ + typedef aux::vector_tag<8> tag; + typedef vector8 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + + + typedef void_ item8; + typedef T7 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,8 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<7> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector8< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef vector7< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<7> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector8< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<8> > +{ + template< typename Vector > struct apply + { + typedef vector7< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6 + > type; + }; +}; + +template< typename V > +struct v_at< V,8 > +{ + typedef typename V::item8 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector9 +{ + typedef aux::vector_tag<9> tag; + typedef vector9 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + + + typedef void_ item9; + typedef T8 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,9 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<8> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector9< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef vector8< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<8> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector9< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<9> > +{ + template< typename Vector > struct apply + { + typedef vector8< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + > type; + }; +}; + +template< typename V > +struct v_at< V,9 > +{ + typedef typename V::item9 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector10 +{ + typedef aux::vector_tag<10> tag; + typedef vector10 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + + + typedef void_ item10; + typedef T9 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,10 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<9> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector10< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef vector9< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<9> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector10< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<10> > +{ + template< typename Vector > struct apply + { + typedef vector9< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8 + > type; + }; +}; + +template< typename V > +struct v_at< V,10 > +{ + typedef typename V::item10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp new file mode 100644 index 0000000000..8b36f6a3ed --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp @@ -0,0 +1,149 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0 + > +struct vector1_c + : vector1< integral_c< T,C0 > > +{ + typedef vector1_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1 + > +struct vector2_c + : vector2< integral_c< T,C0 >, integral_c< T,C1 > > +{ + typedef vector2_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2 + > +struct vector3_c + : vector3< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > > +{ + typedef vector3_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3 + > +struct vector4_c + : vector4< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >, integral_c + > +{ + typedef vector4_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4 + > +struct vector5_c + : vector5< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 > + > +{ + typedef vector5_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5 + > +struct vector6_c + : vector6< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 > + > +{ + typedef vector6_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6 + > +struct vector7_c + : vector7< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c + > +{ + typedef vector7_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 + > +struct vector8_c + : vector8< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 > + > +{ + typedef vector8_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 + > +struct vector9_c + : vector9< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 > + > +{ + typedef vector9_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 + > +struct vector10_c + : vector10< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + > +{ + typedef vector10_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp new file mode 100644 index 0000000000..8c6c8bbb97 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp @@ -0,0 +1,1144 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector11 +{ + typedef aux::vector_tag<11> tag; + typedef vector11 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + + + typedef void_ item11; + typedef T10 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,11 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<10> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector11< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef vector10< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<10> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector11< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<11> > +{ + template< typename Vector > struct apply + { + typedef vector10< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + > type; + }; +}; + +template< typename V > +struct v_at< V,11 > +{ + typedef typename V::item11 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector12 +{ + typedef aux::vector_tag<12> tag; + typedef vector12 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + + + typedef void_ item12; + typedef T11 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,12 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<11> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector12< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef vector11< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<11> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector12< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<12> > +{ + template< typename Vector > struct apply + { + typedef vector11< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10 + > type; + }; +}; + +template< typename V > +struct v_at< V,12 > +{ + typedef typename V::item12 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector13 +{ + typedef aux::vector_tag<13> tag; + typedef vector13 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + + + typedef void_ item13; + typedef T12 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,13 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<12> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector13< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef vector12< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<12> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector13< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<13> > +{ + template< typename Vector > struct apply + { + typedef vector12< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + > type; + }; +}; + +template< typename V > +struct v_at< V,13 > +{ + typedef typename V::item13 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector14 +{ + typedef aux::vector_tag<14> tag; + typedef vector14 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + + + typedef void_ item14; + typedef T13 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,14 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<13> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector14< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef vector13< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<13> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector14< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<14> > +{ + template< typename Vector > struct apply + { + typedef vector13< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12 + > type; + }; +}; + +template< typename V > +struct v_at< V,14 > +{ + typedef typename V::item14 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector15 +{ + typedef aux::vector_tag<15> tag; + typedef vector15 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + + + typedef void_ item15; + typedef T14 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,15 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<14> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector15< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef vector14< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<14> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector15< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<15> > +{ + template< typename Vector > struct apply + { + typedef vector14< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + > type; + }; +}; + +template< typename V > +struct v_at< V,15 > +{ + typedef typename V::item15 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector16 +{ + typedef aux::vector_tag<16> tag; + typedef vector16 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + + + typedef void_ item16; + typedef T15 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,16 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<15> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector16< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef vector15< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<15> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector16< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<16> > +{ + template< typename Vector > struct apply + { + typedef vector15< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14 + > type; + }; +}; + +template< typename V > +struct v_at< V,16 > +{ + typedef typename V::item16 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector17 +{ + typedef aux::vector_tag<17> tag; + typedef vector17 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + + + typedef void_ item17; + typedef T16 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,17 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<16> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector17< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef vector16< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<16> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector17< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<17> > +{ + template< typename Vector > struct apply + { + typedef vector16< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + > type; + }; +}; + +template< typename V > +struct v_at< V,17 > +{ + typedef typename V::item17 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector18 +{ + typedef aux::vector_tag<18> tag; + typedef vector18 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + + + typedef void_ item18; + typedef T17 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,18 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<17> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector18< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef vector17< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<17> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector18< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<18> > +{ + template< typename Vector > struct apply + { + typedef vector17< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16 + > type; + }; +}; + +template< typename V > +struct v_at< V,18 > +{ + typedef typename V::item18 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector19 +{ + typedef aux::vector_tag<19> tag; + typedef vector19 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + + + typedef void_ item19; + typedef T18 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,19 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<18> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector19< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef vector18< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<18> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector19< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<19> > +{ + template< typename Vector > struct apply + { + typedef vector18< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + > type; + }; +}; + +template< typename V > +struct v_at< V,19 > +{ + typedef typename V::item19 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector20 +{ + typedef aux::vector_tag<20> tag; + typedef vector20 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + + + typedef void_ item20; + typedef T19 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,20 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<19> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector20< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef vector19< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<19> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector20< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<20> > +{ + template< typename Vector > struct apply + { + typedef vector19< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18 + > type; + }; +}; + +template< typename V > +struct v_at< V,20 > +{ + typedef typename V::item20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp new file mode 100644 index 0000000000..56ca53f4ea --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp @@ -0,0 +1,195 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + > +struct vector11_c + : vector11< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >, integral_c + > +{ + typedef vector11_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11 + > +struct vector12_c + : vector12< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 > + > +{ + typedef vector12_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12 + > +struct vector13_c + : vector13< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + > +{ + typedef vector13_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13 + > +struct vector14_c + : vector14< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >, integral_c + > +{ + typedef vector14_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14 + > +struct vector15_c + : vector15< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 > + > +{ + typedef vector15_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15 + > +struct vector16_c + : vector16< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + > +{ + typedef vector16_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16 + > +struct vector17_c + : vector17< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >, integral_c + > +{ + typedef vector17_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17 + > +struct vector18_c + : vector18< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 > + > +{ + typedef vector18_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 + > +struct vector19_c + : vector19< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + > +{ + typedef vector19_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 + > +struct vector20_c + : vector20< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >, integral_c + > +{ + typedef vector20_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp new file mode 100644 index 0000000000..b7da8e76b6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp @@ -0,0 +1,1464 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20 + > +struct vector21 +{ + typedef aux::vector_tag<21> tag; + typedef vector21 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + + + typedef void_ item21; + typedef T20 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,21 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<20> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector21< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef vector20< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<20> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector21< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<21> > +{ + template< typename Vector > struct apply + { + typedef vector20< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + > type; + }; +}; + +template< typename V > +struct v_at< V,21 > +{ + typedef typename V::item21 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21 + > +struct vector22 +{ + typedef aux::vector_tag<22> tag; + typedef vector22 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + + + typedef void_ item22; + typedef T21 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,22 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<21> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector22< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef vector21< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<21> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector22< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<22> > +{ + template< typename Vector > struct apply + { + typedef vector21< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20 + > type; + }; +}; + +template< typename V > +struct v_at< V,22 > +{ + typedef typename V::item22 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22 + > +struct vector23 +{ + typedef aux::vector_tag<23> tag; + typedef vector23 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + + + typedef void_ item23; + typedef T22 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,23 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<22> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector23< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef vector22< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<22> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector23< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<23> > +{ + template< typename Vector > struct apply + { + typedef vector22< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + > type; + }; +}; + +template< typename V > +struct v_at< V,23 > +{ + typedef typename V::item23 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23 + > +struct vector24 +{ + typedef aux::vector_tag<24> tag; + typedef vector24 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + + + typedef void_ item24; + typedef T23 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,24 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<23> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector24< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef vector23< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<23> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector24< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<24> > +{ + template< typename Vector > struct apply + { + typedef vector23< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22 + > type; + }; +}; + +template< typename V > +struct v_at< V,24 > +{ + typedef typename V::item24 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + > +struct vector25 +{ + typedef aux::vector_tag<25> tag; + typedef vector25 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + + + typedef void_ item25; + typedef T24 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,25 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<24> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector25< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef vector24< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<24> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector25< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<25> > +{ + template< typename Vector > struct apply + { + typedef vector24< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + > type; + }; +}; + +template< typename V > +struct v_at< V,25 > +{ + typedef typename V::item25 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25 + > +struct vector26 +{ + typedef aux::vector_tag<26> tag; + typedef vector26 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + + + typedef void_ item26; + typedef T25 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,26 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<25> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector26< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef vector25< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<25> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector26< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<26> > +{ + template< typename Vector > struct apply + { + typedef vector25< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24 + > type; + }; +}; + +template< typename V > +struct v_at< V,26 > +{ + typedef typename V::item26 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26 + > +struct vector27 +{ + typedef aux::vector_tag<27> tag; + typedef vector27 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + + + typedef void_ item27; + typedef T26 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,27 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<26> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector27< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef vector26< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<26> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector27< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<27> > +{ + template< typename Vector > struct apply + { + typedef vector26< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + > type; + }; +}; + +template< typename V > +struct v_at< V,27 > +{ + typedef typename V::item27 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27 + > +struct vector28 +{ + typedef aux::vector_tag<28> tag; + typedef vector28 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + + + typedef void_ item28; + typedef T27 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,28 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<27> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector28< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef vector27< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<27> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector28< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<28> > +{ + template< typename Vector > struct apply + { + typedef vector27< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26 + > type; + }; +}; + +template< typename V > +struct v_at< V,28 > +{ + typedef typename V::item28 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28 + > +struct vector29 +{ + typedef aux::vector_tag<29> tag; + typedef vector29 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + + + typedef void_ item29; + typedef T28 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,29 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<28> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector29< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef vector28< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<28> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector29< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<29> > +{ + template< typename Vector > struct apply + { + typedef vector28< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + > type; + }; +}; + +template< typename V > +struct v_at< V,29 > +{ + typedef typename V::item29 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + > +struct vector30 +{ + typedef aux::vector_tag<30> tag; + typedef vector30 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + + + typedef void_ item30; + typedef T29 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,30 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<29> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector30< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef vector29< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<29> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector30< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<30> > +{ + template< typename Vector > struct apply + { + typedef vector29< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28 + > type; + }; +}; + +template< typename V > +struct v_at< V,30 > +{ + typedef typename V::item30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp new file mode 100644 index 0000000000..6251dbc546 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp @@ -0,0 +1,238 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + > +struct vector21_c + : vector21< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 > + > +{ + typedef vector21_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21 + > +struct vector22_c + : vector22< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + > +{ + typedef vector22_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22 + > +struct vector23_c + : vector23< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >, integral_c + > +{ + typedef vector23_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23 + > +struct vector24_c + : vector24< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 > + > +{ + typedef vector24_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24 + > +struct vector25_c + : vector25< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + > +{ + typedef vector25_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25 + > +struct vector26_c + : vector26< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >, integral_c + > +{ + typedef vector26_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26 + > +struct vector27_c + : vector27< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 > + > +{ + typedef vector27_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27 + > +struct vector28_c + : vector28< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + > +{ + typedef vector28_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 + > +struct vector29_c + : vector29< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >, integral_c + > +{ + typedef vector29_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 + > +struct vector30_c + : vector30< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 > + > +{ + typedef vector30_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp new file mode 100644 index 0000000000..7487be4b06 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp @@ -0,0 +1,1784 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30 + > +struct vector31 +{ + typedef aux::vector_tag<31> tag; + typedef vector31 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + + + typedef void_ item31; + typedef T30 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,31 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<30> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector31< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef vector30< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<30> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector31< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<31> > +{ + template< typename Vector > struct apply + { + typedef vector30< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + > type; + }; +}; + +template< typename V > +struct v_at< V,31 > +{ + typedef typename V::item31 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31 + > +struct vector32 +{ + typedef aux::vector_tag<32> tag; + typedef vector32 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + + + typedef void_ item32; + typedef T31 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,32 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<31> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector32< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef vector31< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<31> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector32< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<32> > +{ + template< typename Vector > struct apply + { + typedef vector31< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30 + > type; + }; +}; + +template< typename V > +struct v_at< V,32 > +{ + typedef typename V::item32 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32 + > +struct vector33 +{ + typedef aux::vector_tag<33> tag; + typedef vector33 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + + + typedef void_ item33; + typedef T32 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,33 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<32> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector33< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef vector32< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<32> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector33< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<33> > +{ + template< typename Vector > struct apply + { + typedef vector32< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + > type; + }; +}; + +template< typename V > +struct v_at< V,33 > +{ + typedef typename V::item33 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33 + > +struct vector34 +{ + typedef aux::vector_tag<34> tag; + typedef vector34 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + + + typedef void_ item34; + typedef T33 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,34 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<33> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector34< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef vector33< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<33> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector34< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<34> > +{ + template< typename Vector > struct apply + { + typedef vector33< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32 + > type; + }; +}; + +template< typename V > +struct v_at< V,34 > +{ + typedef typename V::item34 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + > +struct vector35 +{ + typedef aux::vector_tag<35> tag; + typedef vector35 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + + + typedef void_ item35; + typedef T34 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,35 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<34> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector35< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef vector34< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<34> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector35< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<35> > +{ + template< typename Vector > struct apply + { + typedef vector34< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + > type; + }; +}; + +template< typename V > +struct v_at< V,35 > +{ + typedef typename V::item35 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35 + > +struct vector36 +{ + typedef aux::vector_tag<36> tag; + typedef vector36 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + + + typedef void_ item36; + typedef T35 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,36 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<35> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector36< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef vector35< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<35> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector36< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<36> > +{ + template< typename Vector > struct apply + { + typedef vector35< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34 + > type; + }; +}; + +template< typename V > +struct v_at< V,36 > +{ + typedef typename V::item36 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36 + > +struct vector37 +{ + typedef aux::vector_tag<37> tag; + typedef vector37 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + + + typedef void_ item37; + typedef T36 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,37 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<36> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector37< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef vector36< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<36> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector37< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<37> > +{ + template< typename Vector > struct apply + { + typedef vector36< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + > type; + }; +}; + +template< typename V > +struct v_at< V,37 > +{ + typedef typename V::item37 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37 + > +struct vector38 +{ + typedef aux::vector_tag<38> tag; + typedef vector38 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + + + typedef void_ item38; + typedef T37 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,38 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<37> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector38< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef vector37< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<37> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector38< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<38> > +{ + template< typename Vector > struct apply + { + typedef vector37< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36 + > type; + }; +}; + +template< typename V > +struct v_at< V,38 > +{ + typedef typename V::item38 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38 + > +struct vector39 +{ + typedef aux::vector_tag<39> tag; + typedef vector39 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + + + typedef void_ item39; + typedef T38 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,39 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<38> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector39< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef vector38< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<38> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector39< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<39> > +{ + template< typename Vector > struct apply + { + typedef vector38< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + > type; + }; +}; + +template< typename V > +struct v_at< V,39 > +{ + typedef typename V::item39 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + > +struct vector40 +{ + typedef aux::vector_tag<40> tag; + typedef vector40 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + + + typedef void_ item40; + typedef T39 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,40 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<39> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector40< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef vector39< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<39> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector40< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<40> > +{ + template< typename Vector > struct apply + { + typedef vector39< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38 + > type; + }; +}; + +template< typename V > +struct v_at< V,40 > +{ + typedef typename V::item40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp new file mode 100644 index 0000000000..ba0ffa88ee --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp @@ -0,0 +1,281 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + > +struct vector31_c + : vector31< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + > +{ + typedef vector31_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31 + > +struct vector32_c + : vector32< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >, integral_c + > +{ + typedef vector32_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32 + > +struct vector33_c + : vector33< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 > + > +{ + typedef vector33_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33 + > +struct vector34_c + : vector34< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + > +{ + typedef vector34_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34 + > +struct vector35_c + : vector35< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >, integral_c + > +{ + typedef vector35_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35 + > +struct vector36_c + : vector36< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 > + > +{ + typedef vector36_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36 + > +struct vector37_c + : vector37< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + > +{ + typedef vector37_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37 + > +struct vector38_c + : vector38< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >, integral_c + > +{ + typedef vector38_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 + > +struct vector39_c + : vector39< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 > + > +{ + typedef vector39_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 + > +struct vector40_c + : vector40< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + > +{ + typedef vector40_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp new file mode 100644 index 0000000000..5a4c6d75df --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp @@ -0,0 +1,2104 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40 + > +struct vector41 +{ + typedef aux::vector_tag<41> tag; + typedef vector41 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + + + typedef void_ item41; + typedef T40 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,41 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<40> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector41< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef vector40< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<40> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector41< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<41> > +{ + template< typename Vector > struct apply + { + typedef vector40< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + > type; + }; +}; + +template< typename V > +struct v_at< V,41 > +{ + typedef typename V::item41 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41 + > +struct vector42 +{ + typedef aux::vector_tag<42> tag; + typedef vector42 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + + + typedef void_ item42; + typedef T41 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,42 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<41> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector42< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef vector41< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<41> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector42< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<42> > +{ + template< typename Vector > struct apply + { + typedef vector41< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40 + > type; + }; +}; + +template< typename V > +struct v_at< V,42 > +{ + typedef typename V::item42 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42 + > +struct vector43 +{ + typedef aux::vector_tag<43> tag; + typedef vector43 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + + + typedef void_ item43; + typedef T42 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,43 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<42> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector43< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef vector42< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<42> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector43< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<43> > +{ + template< typename Vector > struct apply + { + typedef vector42< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + > type; + }; +}; + +template< typename V > +struct v_at< V,43 > +{ + typedef typename V::item43 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43 + > +struct vector44 +{ + typedef aux::vector_tag<44> tag; + typedef vector44 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + + + typedef void_ item44; + typedef T43 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,44 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<43> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector44< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef vector43< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<43> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector44< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<44> > +{ + template< typename Vector > struct apply + { + typedef vector43< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42 + > type; + }; +}; + +template< typename V > +struct v_at< V,44 > +{ + typedef typename V::item44 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + > +struct vector45 +{ + typedef aux::vector_tag<45> tag; + typedef vector45 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + + + typedef void_ item45; + typedef T44 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,45 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<44> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector45< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef vector44< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<44> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector45< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<45> > +{ + template< typename Vector > struct apply + { + typedef vector44< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + > type; + }; +}; + +template< typename V > +struct v_at< V,45 > +{ + typedef typename V::item45 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45 + > +struct vector46 +{ + typedef aux::vector_tag<46> tag; + typedef vector46 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + + + typedef void_ item46; + typedef T45 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,46 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<45> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector46< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef vector45< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<45> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector46< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<46> > +{ + template< typename Vector > struct apply + { + typedef vector45< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44 + > type; + }; +}; + +template< typename V > +struct v_at< V,46 > +{ + typedef typename V::item46 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46 + > +struct vector47 +{ + typedef aux::vector_tag<47> tag; + typedef vector47 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + + + typedef void_ item47; + typedef T46 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,47 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<46> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector47< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef vector46< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<46> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector47< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<47> > +{ + template< typename Vector > struct apply + { + typedef vector46< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + > type; + }; +}; + +template< typename V > +struct v_at< V,47 > +{ + typedef typename V::item47 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47 + > +struct vector48 +{ + typedef aux::vector_tag<48> tag; + typedef vector48 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + typedef T47 item47; + + + typedef void_ item48; + typedef T47 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,48 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<47> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector48< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef vector47< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + , typename Vector::item47 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<47> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector48< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<48> > +{ + template< typename Vector > struct apply + { + typedef vector47< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46 + > type; + }; +}; + +template< typename V > +struct v_at< V,48 > +{ + typedef typename V::item48 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48 + > +struct vector49 +{ + typedef aux::vector_tag<49> tag; + typedef vector49 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + typedef T47 item47; + typedef T48 item48; + + + typedef void_ item49; + typedef T48 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,49 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<48> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector49< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef vector48< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + , typename Vector::item47, typename Vector::item48 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<48> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector49< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<49> > +{ + template< typename Vector > struct apply + { + typedef vector48< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + > type; + }; +}; + +template< typename V > +struct v_at< V,49 > +{ + typedef typename V::item49 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48, typename T49 + > +struct vector50 +{ + typedef aux::vector_tag<50> tag; + typedef vector50 type; + typedef T0 item0; + typedef T1 item1; + typedef T2 item2; + typedef T3 item3; + typedef T4 item4; + typedef T5 item5; + typedef T6 item6; + typedef T7 item7; + typedef T8 item8; + typedef T9 item9; + typedef T10 item10; + typedef T11 item11; + typedef T12 item12; + typedef T13 item13; + typedef T14 item14; + typedef T15 item15; + typedef T16 item16; + typedef T17 item17; + typedef T18 item18; + typedef T19 item19; + typedef T20 item20; + typedef T21 item21; + typedef T22 item22; + typedef T23 item23; + typedef T24 item24; + typedef T25 item25; + typedef T26 item26; + typedef T27 item27; + typedef T28 item28; + typedef T29 item29; + typedef T30 item30; + typedef T31 item31; + typedef T32 item32; + typedef T33 item33; + typedef T34 item34; + typedef T35 item35; + typedef T36 item36; + typedef T37 item37; + typedef T38 item38; + typedef T39 item39; + typedef T40 item40; + typedef T41 item41; + typedef T42 item42; + typedef T43 item43; + typedef T44 item44; + typedef T45 item45; + typedef T46 item46; + typedef T47 item47; + typedef T48 item48; + typedef T49 item49; + + + typedef void_ item50; + typedef T49 back; + typedef v_iter< type,0 > begin; + typedef v_iter< type,50 > end; +}; + +template<> +struct push_front_impl< aux::vector_tag<49> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector50< + T + , + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , typename Vector::item48 + > type; + }; +}; + +template<> +struct pop_front_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef vector49< + typename Vector::item1, typename Vector::item2 + , typename Vector::item3, typename Vector::item4 + , typename Vector::item5, typename Vector::item6 + , typename Vector::item7, typename Vector::item8 + , typename Vector::item9, typename Vector::item10 + , typename Vector::item11, typename Vector::item12 + , typename Vector::item13, typename Vector::item14 + , typename Vector::item15, typename Vector::item16 + , typename Vector::item17, typename Vector::item18 + , typename Vector::item19, typename Vector::item20 + , typename Vector::item21, typename Vector::item22 + , typename Vector::item23, typename Vector::item24 + , typename Vector::item25, typename Vector::item26 + , typename Vector::item27, typename Vector::item28 + , typename Vector::item29, typename Vector::item30 + , typename Vector::item31, typename Vector::item32 + , typename Vector::item33, typename Vector::item34 + , typename Vector::item35, typename Vector::item36 + , typename Vector::item37, typename Vector::item38 + , typename Vector::item39, typename Vector::item40 + , typename Vector::item41, typename Vector::item42 + , typename Vector::item43, typename Vector::item44 + , typename Vector::item45, typename Vector::item46 + , typename Vector::item47, typename Vector::item48 + , typename Vector::item49 + > type; + }; +}; + +template<> +struct push_back_impl< aux::vector_tag<49> > +{ + template< typename Vector, typename T > struct apply + { + typedef vector50< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , typename Vector::item48 + , + T + > type; + }; +}; + +template<> +struct pop_back_impl< aux::vector_tag<50> > +{ + template< typename Vector > struct apply + { + typedef vector49< + typename Vector::item0, typename Vector::item1 + , typename Vector::item2, typename Vector::item3 + , typename Vector::item4, typename Vector::item5 + , typename Vector::item6, typename Vector::item7 + , typename Vector::item8, typename Vector::item9 + , typename Vector::item10, typename Vector::item11 + , typename Vector::item12, typename Vector::item13 + , typename Vector::item14, typename Vector::item15 + , typename Vector::item16, typename Vector::item17 + , typename Vector::item18, typename Vector::item19 + , typename Vector::item20, typename Vector::item21 + , typename Vector::item22, typename Vector::item23 + , typename Vector::item24, typename Vector::item25 + , typename Vector::item26, typename Vector::item27 + , typename Vector::item28, typename Vector::item29 + , typename Vector::item30, typename Vector::item31 + , typename Vector::item32, typename Vector::item33 + , typename Vector::item34, typename Vector::item35 + , typename Vector::item36, typename Vector::item37 + , typename Vector::item38, typename Vector::item39 + , typename Vector::item40, typename Vector::item41 + , typename Vector::item42, typename Vector::item43 + , typename Vector::item44, typename Vector::item45 + , typename Vector::item46, typename Vector::item47 + , typename Vector::item48 + > type; + }; +}; + +template< typename V > +struct v_at< V,50 > +{ + typedef typename V::item50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp new file mode 100644 index 0000000000..e07f2b3ad5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp @@ -0,0 +1,325 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + > +struct vector41_c + : vector41< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >, integral_c + > +{ + typedef vector41_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41 + > +struct vector42_c + : vector42< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 > + > +{ + typedef vector42_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42 + > +struct vector43_c + : vector43< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + > +{ + typedef vector43_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43 + > +struct vector44_c + : vector44< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >, integral_c + > +{ + typedef vector44_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44 + > +struct vector45_c + : vector45< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 > + > +{ + typedef vector45_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45 + > +struct vector46_c + : vector46< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + > +{ + typedef vector46_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46 + > +struct vector47_c + : vector47< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >, integral_c + > +{ + typedef vector47_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47 + > +struct vector48_c + : vector48< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + , integral_c< T,C46 >, integral_c< T,C47 > + > +{ + typedef vector48_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 + > +struct vector49_c + : vector49< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 > + > +{ + typedef vector49_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 + > +struct vector50_c + : vector50< + integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > + , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > + , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > + , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > + , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > + , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > + , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > + , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > + , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > + , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > + , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > + , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > + , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > + , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > + , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > + , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >, integral_c + > +{ + typedef vector50_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp new file mode 100644 index 0000000000..e4c640709a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp @@ -0,0 +1,139 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector10.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0 + > +struct vector1 + : v_item< + T0 + , vector0< > + > +{ + typedef vector1 type; +}; + +template< + typename T0, typename T1 + > +struct vector2 + : v_item< + T1 + , vector1 + > +{ + typedef vector2 type; +}; + +template< + typename T0, typename T1, typename T2 + > +struct vector3 + : v_item< + T2 + , vector2< T0,T1 > + > +{ + typedef vector3 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3 + > +struct vector4 + : v_item< + T3 + , vector3< T0,T1,T2 > + > +{ + typedef vector4 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + > +struct vector5 + : v_item< + T4 + , vector4< T0,T1,T2,T3 > + > +{ + typedef vector5 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct vector6 + : v_item< + T5 + , vector5< T0,T1,T2,T3,T4 > + > +{ + typedef vector6 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6 + > +struct vector7 + : v_item< + T6 + , vector6< T0,T1,T2,T3,T4,T5 > + > +{ + typedef vector7 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7 + > +struct vector8 + : v_item< + T7 + , vector7< T0,T1,T2,T3,T4,T5,T6 > + > +{ + typedef vector8 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8 + > +struct vector9 + : v_item< + T8 + , vector8< T0,T1,T2,T3,T4,T5,T6,T7 > + > +{ + typedef vector9 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + > +struct vector10 + : v_item< + T9 + , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > + > +{ + typedef vector10 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp new file mode 100644 index 0000000000..18eabc64da --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp @@ -0,0 +1,154 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0 + > +struct vector1_c + : v_item< + integral_c< T,C0 > + , vector0_c + > +{ + typedef vector1_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1 + > +struct vector2_c + : v_item< + integral_c< T,C1 > + , vector1_c< T,C0 > + > +{ + typedef vector2_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2 + > +struct vector3_c + : v_item< + integral_c< T,C2 > + , vector2_c< T,C0,C1 > + > +{ + typedef vector3_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3 + > +struct vector4_c + : v_item< + integral_c< T,C3 > + , vector3_c< T,C0,C1,C2 > + > +{ + typedef vector4_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4 + > +struct vector5_c + : v_item< + integral_c< T,C4 > + , vector4_c< T,C0,C1,C2,C3 > + > +{ + typedef vector5_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5 + > +struct vector6_c + : v_item< + integral_c< T,C5 > + , vector5_c< T,C0,C1,C2,C3,C4 > + > +{ + typedef vector6_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6 + > +struct vector7_c + : v_item< + integral_c< T,C6 > + , vector6_c< T,C0,C1,C2,C3,C4,C5 > + > +{ + typedef vector7_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 + > +struct vector8_c + : v_item< + integral_c< T,C7 > + , vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > + > +{ + typedef vector8_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 + > +struct vector9_c + : v_item< + integral_c< T,C8 > + , vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > + > +{ + typedef vector9_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 + > +struct vector10_c + : v_item< + integral_c< T,C9 > + , vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > + > +{ + typedef vector10_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp new file mode 100644 index 0000000000..78ccac4e91 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp @@ -0,0 +1,159 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector20.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10 + > +struct vector11 + : v_item< + T10 + , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > + > +{ + typedef vector11 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11 + > +struct vector12 + : v_item< + T11 + , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > + > +{ + typedef vector12 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12 + > +struct vector13 + : v_item< + T12 + , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > + > +{ + typedef vector13 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13 + > +struct vector14 + : v_item< + T13 + , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > + > +{ + typedef vector14 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + > +struct vector15 + : v_item< + T14 + , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > + > +{ + typedef vector15 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15 + > +struct vector16 + : v_item< + T15 + , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 > + > +{ + typedef vector16 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16 + > +struct vector17 + : v_item< + T16 + , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 > + > +{ + typedef vector17 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17 + > +struct vector18 + : v_item< + T17 + , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 > + > +{ + typedef vector18 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18 + > +struct vector19 + : v_item< + T18 + , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 > + > +{ + typedef vector19 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + > +struct vector20 + : v_item< + T19 + , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 > + > +{ + typedef vector20 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp new file mode 100644 index 0000000000..4bf6742306 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp @@ -0,0 +1,163 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + > +struct vector11_c + : v_item< + integral_c< T,C10 > + , vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > + > +{ + typedef vector11_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11 + > +struct vector12_c + : v_item< + integral_c< T,C11 > + , vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > + > +{ + typedef vector12_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12 + > +struct vector13_c + : v_item< + integral_c< T,C12 > + , vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > + > +{ + typedef vector13_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13 + > +struct vector14_c + : v_item< + integral_c< T,C13 > + , vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > + > +{ + typedef vector14_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14 + > +struct vector15_c + : v_item< + integral_c< T,C14 > + , vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 > + > +{ + typedef vector15_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15 + > +struct vector16_c + : v_item< + integral_c< T,C15 > + , vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 > + > +{ + typedef vector16_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16 + > +struct vector17_c + : v_item< + integral_c< T,C16 > + , vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 > + > +{ + typedef vector17_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17 + > +struct vector18_c + : v_item< + integral_c< T,C17 > + , vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 > + > +{ + typedef vector18_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 + > +struct vector19_c + : v_item< + integral_c< T,C18 > + , vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 > + > +{ + typedef vector19_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 + > +struct vector20_c + : v_item< + integral_c< T,C19 > + , vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 > + > +{ + typedef vector20_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp new file mode 100644 index 0000000000..c4049906f3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp @@ -0,0 +1,179 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector30.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20 + > +struct vector21 + : v_item< + T20 + , vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 > + > +{ + typedef vector21 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21 + > +struct vector22 + : v_item< + T21 + , vector21< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 > + > +{ + typedef vector22 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22 + > +struct vector23 + : v_item< + T22 + , vector22< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 > + > +{ + typedef vector23 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23 + > +struct vector24 + : v_item< + T23 + , vector23< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 > + > +{ + typedef vector24 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + > +struct vector25 + : v_item< + T24 + , vector24< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 > + > +{ + typedef vector25 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25 + > +struct vector26 + : v_item< + T25 + , vector25< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 > + > +{ + typedef vector26 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26 + > +struct vector27 + : v_item< + T26 + , vector26< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 > + > +{ + typedef vector27 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27 + > +struct vector28 + : v_item< + T27 + , vector27< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 > + > +{ + typedef vector28 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28 + > +struct vector29 + : v_item< + T28 + , vector28< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 > + > +{ + typedef vector29 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + > +struct vector30 + : v_item< + T29 + , vector29< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 > + > +{ + typedef vector30 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp new file mode 100644 index 0000000000..5741bb4b65 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp @@ -0,0 +1,173 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + > +struct vector21_c + : v_item< + integral_c< T,C20 > + , vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 > + > +{ + typedef vector21_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21 + > +struct vector22_c + : v_item< + integral_c< T,C21 > + , vector21_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 > + > +{ + typedef vector22_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22 + > +struct vector23_c + : v_item< + integral_c< T,C22 > + , vector22_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 > + > +{ + typedef vector23_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23 + > +struct vector24_c + : v_item< + integral_c< T,C23 > + , vector23_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 > + > +{ + typedef vector24_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24 + > +struct vector25_c + : v_item< + integral_c< T,C24 > + , vector24_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 > + > +{ + typedef vector25_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25 + > +struct vector26_c + : v_item< + integral_c< T,C25 > + , vector25_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 > + > +{ + typedef vector26_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26 + > +struct vector27_c + : v_item< + integral_c< T,C26 > + , vector26_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 > + > +{ + typedef vector27_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27 + > +struct vector28_c + : v_item< + integral_c< T,C27 > + , vector27_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 > + > +{ + typedef vector28_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 + > +struct vector29_c + : v_item< + integral_c< T,C28 > + , vector28_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 > + > +{ + typedef vector29_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 + > +struct vector30_c + : v_item< + integral_c< T,C29 > + , vector29_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 > + > +{ + typedef vector30_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp new file mode 100644 index 0000000000..debcf7027d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp @@ -0,0 +1,199 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector40.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30 + > +struct vector31 + : v_item< + T30 + , vector30< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29 > + > +{ + typedef vector31 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31 + > +struct vector32 + : v_item< + T31 + , vector31< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30 > + > +{ + typedef vector32 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32 + > +struct vector33 + : v_item< + T32 + , vector32< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31 > + > +{ + typedef vector33 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33 + > +struct vector34 + : v_item< + T33 + , vector33< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32 > + > +{ + typedef vector34 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + > +struct vector35 + : v_item< + T34 + , vector34< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33 > + > +{ + typedef vector35 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35 + > +struct vector36 + : v_item< + T35 + , vector35< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34 > + > +{ + typedef vector36 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36 + > +struct vector37 + : v_item< + T36 + , vector36< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35 > + > +{ + typedef vector37 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37 + > +struct vector38 + : v_item< + T37 + , vector37< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36 > + > +{ + typedef vector38 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38 + > +struct vector39 + : v_item< + T38 + , vector38< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37 > + > +{ + typedef vector39 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + > +struct vector40 + : v_item< + T39 + , vector39< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38 > + > +{ + typedef vector40 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp new file mode 100644 index 0000000000..88d742e0a5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp @@ -0,0 +1,183 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + > +struct vector31_c + : v_item< + integral_c< T,C30 > + , vector30_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29 > + > +{ + typedef vector31_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31 + > +struct vector32_c + : v_item< + integral_c< T,C31 > + , vector31_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30 > + > +{ + typedef vector32_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32 + > +struct vector33_c + : v_item< + integral_c< T,C32 > + , vector32_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31 > + > +{ + typedef vector33_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33 + > +struct vector34_c + : v_item< + integral_c< T,C33 > + , vector33_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32 > + > +{ + typedef vector34_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34 + > +struct vector35_c + : v_item< + integral_c< T,C34 > + , vector34_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33 > + > +{ + typedef vector35_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35 + > +struct vector36_c + : v_item< + integral_c< T,C35 > + , vector35_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34 > + > +{ + typedef vector36_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36 + > +struct vector37_c + : v_item< + integral_c< T,C36 > + , vector36_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35 > + > +{ + typedef vector37_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37 + > +struct vector38_c + : v_item< + integral_c< T,C37 > + , vector37_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36 > + > +{ + typedef vector38_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 + > +struct vector39_c + : v_item< + integral_c< T,C38 > + , vector38_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37 > + > +{ + typedef vector39_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 + > +struct vector40_c + : v_item< + integral_c< T,C39 > + , vector39_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38 > + > +{ + typedef vector40_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp new file mode 100644 index 0000000000..8db06df454 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp @@ -0,0 +1,219 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector50.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40 + > +struct vector41 + : v_item< + T40 + , vector40< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39 > + > +{ + typedef vector41 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41 + > +struct vector42 + : v_item< + T41 + , vector41< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40 > + > +{ + typedef vector42 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42 + > +struct vector43 + : v_item< + T42 + , vector42< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41 > + > +{ + typedef vector43 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43 + > +struct vector44 + : v_item< + T43 + , vector43< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42 > + > +{ + typedef vector44 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + > +struct vector45 + : v_item< + T44 + , vector44< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43 > + > +{ + typedef vector45 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45 + > +struct vector46 + : v_item< + T45 + , vector45< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44 > + > +{ + typedef vector46 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46 + > +struct vector47 + : v_item< + T46 + , vector46< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45 > + > +{ + typedef vector47 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47 + > +struct vector48 + : v_item< + T47 + , vector47< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46 > + > +{ + typedef vector48 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48 + > +struct vector49 + : v_item< + T48 + , vector48< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47 > + > +{ + typedef vector49 type; +}; + +template< + typename T0, typename T1, typename T2, typename T3, typename T4 + , typename T5, typename T6, typename T7, typename T8, typename T9 + , typename T10, typename T11, typename T12, typename T13, typename T14 + , typename T15, typename T16, typename T17, typename T18, typename T19 + , typename T20, typename T21, typename T22, typename T23, typename T24 + , typename T25, typename T26, typename T27, typename T28, typename T29 + , typename T30, typename T31, typename T32, typename T33, typename T34 + , typename T35, typename T36, typename T37, typename T38, typename T39 + , typename T40, typename T41, typename T42, typename T43, typename T44 + , typename T45, typename T46, typename T47, typename T48, typename T49 + > +struct vector50 + : v_item< + T49 + , vector49< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48 > + > +{ + typedef vector50 type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp new file mode 100644 index 0000000000..f56d6aff06 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp @@ -0,0 +1,193 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + > +struct vector41_c + : v_item< + integral_c< T,C40 > + , vector40_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39 > + > +{ + typedef vector41_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41 + > +struct vector42_c + : v_item< + integral_c< T,C41 > + , vector41_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40 > + > +{ + typedef vector42_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42 + > +struct vector43_c + : v_item< + integral_c< T,C42 > + , vector42_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41 > + > +{ + typedef vector43_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43 + > +struct vector44_c + : v_item< + integral_c< T,C43 > + , vector43_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42 > + > +{ + typedef vector44_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44 + > +struct vector45_c + : v_item< + integral_c< T,C44 > + , vector44_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43 > + > +{ + typedef vector45_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45 + > +struct vector46_c + : v_item< + integral_c< T,C45 > + , vector45_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44 > + > +{ + typedef vector46_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46 + > +struct vector47_c + : v_item< + integral_c< T,C46 > + , vector46_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45 > + > +{ + typedef vector47_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47 + > +struct vector48_c + : v_item< + integral_c< T,C47 > + , vector47_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46 > + > +{ + typedef vector48_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 + > +struct vector49_c + : v_item< + integral_c< T,C48 > + , vector48_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47 > + > +{ + typedef vector49_c type; + typedef T value_type; +}; + +template< + typename T + , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 + , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 + , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 + , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 + , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 + > +struct vector50_c + : v_item< + integral_c< T,C49 > + , vector49_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48 > + > +{ + typedef vector50_c type; + typedef T value_type; +}; + +}} diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/push_back.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/push_back.hpp new file mode 100644 index 0000000000..ab7197116b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/push_back.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/push_back.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# include +# include + +namespace boost { namespace mpl { + +template<> +struct push_back_impl< aux::vector_tag > +{ + template< typename Vector, typename T > struct apply + { + typedef v_item type; + }; +}; + +}} + +#endif + +#endif // BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/push_front.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/push_front.hpp new file mode 100644 index 0000000000..1ea7f2cf1a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/push_front.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/push_front.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +# include +# include + +namespace boost { namespace mpl { + +template<> +struct push_front_impl< aux::vector_tag > +{ + template< typename Vector, typename T > struct apply + { + typedef v_item type; + }; +}; + +}} + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +#endif // BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/size.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/size.hpp new file mode 100644 index 0000000000..f20297d25a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/size.hpp @@ -0,0 +1,49 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/size.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + +template<> +struct size_impl< aux::vector_tag > + : O1_size_impl< aux::vector_tag > +{ +}; + +#else + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< long N > +struct size_impl< aux::vector_tag > + : O1_size_impl< aux::vector_tag > +{ +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES + +}} + +#endif // BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/tag.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/tag.hpp new file mode 100644 index 0000000000..03beee98d3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/tag.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/tag.hpp,v $ +// $Date: 2004/11/28 01:52:12 $ +// $Revision: 1.5 $ + +#include +#include + +namespace boost { namespace mpl { namespace aux { + +struct v_iter_tag; + +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) +struct vector_tag; +#else +template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct vector_tag; +#endif + +}}} + +#endif // BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/aux_/vector0.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/vector0.hpp new file mode 100644 index 0000000000..98797f47e8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/aux_/vector0.hpp @@ -0,0 +1,52 @@ + +#ifndef BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED +#define BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/aux_/vector0.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include + +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Dummy = na > struct vector0; + +template<> struct vector0 +{ +#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) + typedef aux::vector_tag tag; + typedef vector0 type; + typedef long_<32768> lower_bound_; + typedef lower_bound_ upper_bound_; + typedef long_<0> size; + + static aux::type_wrapper item_(...); +#else + typedef aux::vector_tag<0> tag; + typedef vector0 type; + typedef void_ item0; + + typedef v_iter,0> begin; + typedef v_iter,0> end; +#endif +}; + +}} + +#endif // BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector0.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector0.hpp new file mode 100644 index 0000000000..84792c264f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector0.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector0.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.4 $ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector0_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector0_c.hpp new file mode 100644 index 0000000000..13e6297b6e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector0_c.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR0_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR0_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector0_c.hpp,v $ +// $Date: 2004/11/28 01:52:56 $ +// $Revision: 1.5 $ + +#include +#include + +namespace boost { namespace mpl { + +template< typename T > struct vector0_c + : vector0<> +{ + typedef vector0_c type; + typedef T value_type; +}; + +}} + +#endif // BOOST_MPL_VECTOR_VECTOR0_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector10.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector10.hpp new file mode 100644 index 0000000000..cd4f9760cf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector10.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector10.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector10.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector10_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector10_c.hpp new file mode 100644 index 0000000000..b5419c448d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector10_c.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR10_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR10_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector10_c.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector10_c.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, 10, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR10_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector20.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector20.hpp new file mode 100644 index 0000000000..25557df3d8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector20.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector20.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector20.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector20_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector20_c.hpp new file mode 100644 index 0000000000..2682254aa5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector20_c.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector20_c.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector20_c.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(11, 20, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector30.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector30.hpp new file mode 100644 index 0000000000..55f772e561 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector30.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR30_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR30_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector30.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector30.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR30_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector30_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector30_c.hpp new file mode 100644 index 0000000000..2a1b4cae51 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector30_c.hpp @@ -0,0 +1,47 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR30_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR30_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector30_c.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector30_c.hpp +# include + +#else + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(21, 30, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_USE_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR30_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector40.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector40.hpp new file mode 100644 index 0000000000..1c9f81d27c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector40.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR40_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR40_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector40.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector40.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR40_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector40_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector40_c.hpp new file mode 100644 index 0000000000..a62b3b38e9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector40_c.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR40_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR40_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector40_c.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector40_c.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(31, 40, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR40_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector50.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector50.hpp new file mode 100644 index 0000000000..119798ff83 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector50.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR50_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR50_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector50.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector50.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR50_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector/vector50_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector/vector50_c.hpp new file mode 100644 index 0000000000..96f9488026 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector/vector50_c.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_VECTOR_VECTOR50_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_VECTOR50_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector/vector50_c.hpp,v $ +// $Date: 2004/09/02 15:41:19 $ +// $Revision: 1.6 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector50_c.hpp +# include + +#else + +# include +# include +# include + +namespace boost { namespace mpl { + +# define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(41, 50, )) +# include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_VECTOR_VECTOR50_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/vector_c.hpp b/deal.II/contrib/boost/include/boost/mpl/vector_c.hpp new file mode 100644 index 0000000000..f0c326a92b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/vector_c.hpp @@ -0,0 +1,60 @@ + +#ifndef BOOST_MPL_VECTOR_C_HPP_INCLUDED +#define BOOST_MPL_VECTOR_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/vector_c.hpp,v $ +// $Date: 2004/11/28 01:58:27 $ +// $Revision: 1.8 $ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include + +# include +# include +# include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_VECTOR_C_HEADER \ + BOOST_PP_CAT(BOOST_PP_CAT(vector,BOOST_MPL_LIMIT_VECTOR_SIZE),_c).hpp \ + /**/ +#else +# define AUX778076_VECTOR_C_HEADER \ + BOOST_PP_CAT(BOOST_PP_CAT(vector,BOOST_MPL_LIMIT_VECTOR_SIZE),_c)##.hpp \ + /**/ +#endif + +# include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_C_HEADER) +# undef AUX778076_VECTOR_C_HEADER +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER vector_c.hpp +# include + +#else + +# include + +# define AUX778076_SEQUENCE_NAME vector_c +# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE +# define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(vector,n),_c) +# define AUX778076_SEQUENCE_INTEGRAL_WRAPPER +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_VECTOR_C_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/void.hpp b/deal.II/contrib/boost/include/boost/mpl/void.hpp new file mode 100644 index 0000000000..9c429a3f81 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/void.hpp @@ -0,0 +1,76 @@ + +#ifndef BOOST_MPL_VOID_HPP_INCLUDED +#define BOOST_MPL_VOID_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/void.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.9 $ + +#include +#include +#include +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +// [JDG Feb-4-2003] made void_ a complete type to allow it to be +// instantiated so that it can be passed in as an object that can be +// used to select an overloaded function. Possible use includes signaling +// a zero arity functor evaluation call. +struct void_ { typedef void_ type; }; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +namespace boost { namespace mpl { + +template< typename T > +struct is_void_ + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +template<> +struct is_void_ + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +template< typename T > +struct is_not_void_ + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +template<> +struct is_not_void_ + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +BOOST_MPL_AUX_NA_SPEC(1, is_void_) +BOOST_MPL_AUX_NA_SPEC(1, is_not_void_) + +}} + +#endif // BOOST_MPL_VOID_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/void_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/void_fwd.hpp index 7179b2a326..7d1c0f8b65 100644 --- a/deal.II/contrib/boost/include/boost/mpl/void_fwd.hpp +++ b/deal.II/contrib/boost/include/boost/mpl/void_fwd.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Source$ +// $Source: /cvsroot/boost/boost/boost/mpl/void_fwd.hpp,v $ // $Date$ // $Revision$ diff --git a/deal.II/contrib/boost/include/boost/mpl/zip_view.hpp b/deal.II/contrib/boost/include/boost/mpl/zip_view.hpp new file mode 100644 index 0000000000..c09215c766 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/zip_view.hpp @@ -0,0 +1,64 @@ + +#ifndef BOOST_MPL_ZIP_VIEW_HPP_INCLUDED +#define BOOST_MPL_ZIP_VIEW_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2002 +// Copyright David Abrahams 2000-2002 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Source: /cvsroot/boost/boost/boost/mpl/zip_view.hpp,v $ +// $Date: 2004/09/02 15:40:42 $ +// $Revision: 1.3 $ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename IteratorSeq > +struct zip_iterator +{ + typedef forward_iterator_tag category; + typedef typename transform1< + IteratorSeq + , deref<_1> + >::type type; + + typedef zip_iterator< + typename transform1< + IteratorSeq + , next<_1> + >::type + > next; +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(Sequences) + > +struct zip_view +{ + private: + typedef typename transform1< Sequences, begin<_1> >::type first_ones_; + typedef typename transform1< Sequences, end<_1> >::type last_ones_; + + public: + typedef nested_begin_end_tag tag; + typedef zip_iterator begin; + typedef zip_iterator end; +}; + +BOOST_MPL_AUX_NA_SPEC(1, zip_view) + +}} + +#endif // BOOST_MPL_ZIP_VIEW_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/optional/optional.hpp b/deal.II/contrib/boost/include/boost/optional/optional.hpp new file mode 100644 index 0000000000..99f3af028d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/optional/optional.hpp @@ -0,0 +1,749 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/lib/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP +#define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP + +#include +#include + +#include "boost/config.hpp" +#include "boost/assert.hpp" +#include "boost/type.hpp" +#include "boost/type_traits/alignment_of.hpp" +#include "boost/type_traits/type_with_alignment.hpp" +#include "boost/type_traits/remove_reference.hpp" +#include "boost/type_traits/is_reference.hpp" +#include "boost/mpl/if.hpp" +#include "boost/mpl/bool.hpp" +#include "boost/mpl/not.hpp" +#include "boost/detail/reference_content.hpp" +#include "boost/none_t.hpp" +#include "boost/utility/compare_pointees.hpp" + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) +// VC6.0 has the following bug: +// When a templated assignment operator exist, an implicit conversion +// constructing an optional is used when assigment of the form: +// optional opt ; opt = T(...); +// is compiled. +// However, optional's ctor is _explicit_ and the assignemt shouldn't compile. +// Therefore, for VC6.0 templated assignment is disabled. +// +#define BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) +// VC7.0 has the following bug: +// When both a non-template and a template copy-ctor exist +// and the templated version is made 'explicit', the explicit is also +// given to the non-templated version, making the class non-implicitely-copyable. +// +#define BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700) +// AFAICT only VC7.1 correctly resolves the overload set +// that includes the in-place factory taking functions, +// so for the other VC versions, in-place factory support +// is disabled +#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551) +// BCB (5.5.1) cannot parse the nested template struct in an inplace factory. +#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT +#endif + +#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \ + && BOOST_WORKAROUND(__BORLANDC__, <= 0x564) +// BCB (up to 5.64) has the following bug: +// If there is a member function/operator template of the form +// template mfunc( Expr expr ) ; +// some calls are resolved to this even if there are other better matches. +// The effect of this bug is that calls to converting ctors and assignments +// are incrorrectly sink to this general catch-all member function template as shown above. +#define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION +#endif + + +namespace boost { + +class in_place_factory_base ; +class typed_in_place_factory_base ; + +namespace optional_detail { + +// This local class is used instead of that in "aligned_storage.hpp" +// because I've found the 'official' class to ICE BCB5.5 +// when some types are used with optional<> +// (due to sizeof() passed down as a non-type template parameter) +template +class aligned_storage +{ + // Borland ICEs if unnamed unions are used for this! + union dummy_u + { + char data[ sizeof(T) ]; + BOOST_DEDUCED_TYPENAME type_with_alignment< + ::boost::alignment_of::value >::type aligner_; + } dummy_ ; + + public: + + void const* address() const { return &dummy_.data[0]; } + void * address() { return &dummy_.data[0]; } +} ; + +template +struct types_when_isnt_ref +{ + typedef T const& reference_const_type ; + typedef T & reference_type ; + typedef T const* pointer_const_type ; + typedef T * pointer_type ; + typedef T const& argument_type ; +} ; +template +struct types_when_is_ref +{ + typedef BOOST_DEDUCED_TYPENAME remove_reference::type raw_type ; + + typedef raw_type& reference_const_type ; + typedef raw_type& reference_type ; + typedef raw_type* pointer_const_type ; + typedef raw_type* pointer_type ; + typedef raw_type& argument_type ; +} ; + +struct optional_tag {} ; + +template +class optional_base : public optional_tag +{ + private : + + typedef BOOST_DEDUCED_TYPENAME detail::make_reference_content::type internal_type ; + + typedef aligned_storage storage_type ; + + typedef types_when_isnt_ref types_when_not_ref ; + typedef types_when_is_ref types_when_ref ; + + typedef optional_base this_type ; + + protected : + + typedef T value_type ; + + typedef mpl::true_ is_reference_tag ; + typedef mpl::false_ is_not_reference_tag ; + + typedef BOOST_DEDUCED_TYPENAME is_reference::type is_reference_predicate ; + + typedef BOOST_DEDUCED_TYPENAME mpl::if_::type types ; + + typedef bool (this_type::*unspecified_bool_type)() const; + + typedef BOOST_DEDUCED_TYPENAME types::reference_type reference_type ; + typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ; + typedef BOOST_DEDUCED_TYPENAME types::pointer_type pointer_type ; + typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type pointer_const_type ; + typedef BOOST_DEDUCED_TYPENAME types::argument_type argument_type ; + + // Creates an optional uninitialized. + // No-throw + optional_base() + : + m_initialized(false) {} + + // Creates an optional uninitialized. + // No-throw + optional_base ( none_t const& ) + : + m_initialized(false) {} + + // Creates an optional initialized with 'val'. + // Can throw if T::T(T const&) does + optional_base ( argument_type val ) + : + m_initialized(false) + { + construct(val); + } + + // Creates a deep copy of another optional + // Can throw if T::T(T const&) does + optional_base ( optional_base const& rhs ) + : + m_initialized(false) + { + if ( rhs.is_initialized() ) + construct(rhs.get_impl()); + } + + + // This is used for both converting and in-place constructions. + // Derived classes use the 'tag' to select the appropriate + // implementation (the correct 'construct()' overload) + template + explicit optional_base ( Expr const& expr, Expr const* tag ) + : + m_initialized(false) + { + construct(expr,tag); + } + + + + // No-throw (assuming T::~T() doesn't) + ~optional_base() { destroy() ; } + + // Assigns from another optional (deep-copies the rhs value) + void assign ( optional_base const& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(rhs.get_impl(), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(rhs.get_impl()); + } + } + + // Assigns from a T (deep-copies the rhs value) + void assign ( argument_type val ) + { + if (is_initialized()) + assign_value(val, is_reference_predicate() ); + else construct(val); + } + + // Assigns from "none", destroying the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void assign ( none_t const& ) { destroy(); } + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + template + void assign_expr ( Expr const& expr, Expr const* tag ) + { + if (is_initialized()) + assign_expr_to_initialized(expr,tag); + else construct(expr,tag); + } +#endif + + public : + + // Destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void reset() { destroy(); } + + // Replaces the current value -if any- with 'val' + void reset ( argument_type val ) { assign(val); } + + // Returns a pointer to the value if this is initialized, otherwise, + // returns NULL. + // No-throw + pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } + pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } + + bool is_initialized() const { return m_initialized ; } + + protected : + + void construct ( argument_type val ) + { + new (m_storage.address()) internal_type(val) ; + m_initialized = true ; + } + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + // Constructs in-place using the given factory + template + void construct ( Expr const& factory, in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + factory.BOOST_NESTED_TEMPLATE apply(m_storage.address()) ; + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr const& factory, typed_in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + factory.apply(m_storage.address()) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } +#endif + + // Constructs using any expression implicitely convertible to the single argument + // of a one-argument T constructor. + // Converting constructions of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr const& expr, void const* ) + { + new (m_storage.address()) internal_type(expr) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitely convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr const& expr, void const* ) + { + assign_value(expr, is_reference_predicate()); + } + +#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + // BCB5.64 (and probably lower versions) workaround. + // The in-place factories are supported by means of catch-all constructors + // and assignment operators (the functions are parameterized in terms of + // an arbitrary 'Expr' type) + // This compiler incorrectly resolves the overload set and sinks optional and optional + // to the 'Expr'-taking functions even though explicit overloads are present for them. + // Thus, the following overload is needed to properly handle the case when the 'lhs' + // is another optional. + // + // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error + // instead of choosing the wrong overload + // + // Notice that 'Expr' will be optional or optional (but not optional_base<..>) + template + void construct ( Expr const& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + new (m_storage.address()) internal_type(expr.get()) ; + m_initialized = true ; + } + } +#endif + + void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; } + void assign_value ( argument_type val, is_reference_tag ) { construct(val); } + + void destroy() + { + if ( m_initialized ) + destroy_impl(is_reference_predicate()) ; + } + + unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; } + + reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; } + reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; } + + pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; } + pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; } + + private : + + // internal_type can be either T or reference_content + internal_type const* get_object() const { return static_cast(m_storage.address()); } + internal_type * get_object() { return static_cast (m_storage.address()); } + + // reference_content lacks an implicit conversion to T&, so the following is needed to obtain a proper reference. + reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; } + reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; } + reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; } + reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; } + +#if BOOST_WORKAROUND(__BORLANDC__, <= 0x564) + void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; } +#else + void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->T::~T() ; m_initialized = false ; } +#endif + + void destroy_impl ( is_reference_tag ) { m_initialized = false ; } + + // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error. + // Decent compilers should disallow conversions from reference_content* to T*, but just in case, + // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference. + pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; } + pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; } + + bool m_initialized ; + storage_type m_storage ; +} ; + +} // namespace optional_detail + +template +class optional : public optional_detail::optional_base +{ + typedef optional_detail::optional_base base ; + + typedef BOOST_DEDUCED_TYPENAME base::unspecified_bool_type unspecified_bool_type ; + + public : + + typedef optional this_type ; + + typedef BOOST_DEDUCED_TYPENAME base::value_type value_type ; + typedef BOOST_DEDUCED_TYPENAME base::reference_type reference_type ; + typedef BOOST_DEDUCED_TYPENAME base::reference_const_type reference_const_type ; + typedef BOOST_DEDUCED_TYPENAME base::pointer_type pointer_type ; + typedef BOOST_DEDUCED_TYPENAME base::pointer_const_type pointer_const_type ; + typedef BOOST_DEDUCED_TYPENAME base::argument_type argument_type ; + + // Creates an optional uninitialized. + // No-throw + optional() : base() {} + + // Creates an optional uninitialized. + // No-throw + optional( none_t const& none_ ) : base(none_) {} + + // Creates an optional initialized with 'val'. + // Can throw if T::T(T const&) does + optional ( argument_type val ) : base(val) {} + + +#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR + // NOTE: MSVC needs templated versions first + + // Creates a deep copy of another convertible optional + // Requires a valid conversion from U to T. + // Can throw if T::T(U const&) does + template + explicit optional ( optional const& rhs ) + : + base() + { + if ( rhs.is_initialized() ) + this->construct(rhs.get()); + } +#endif + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + // Creates an optional with an expression which can be either + // (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n); + // (b) An instance of TypedInPlaceFactory ( i.e. in_place(a,b,...,n); + // (c) Any expression implicitely convertible to the single type + // of a one-argument T's constructor. + // (d*) Weak compilers (BCB) might also resolved Expr as optional and optional + // even though explicit overloads are present for these. + // Depending on the above some T ctor is called. + // Can throw is the resolved T ctor throws. + template + explicit optional ( Expr const& expr ) : base(expr,&expr) {} +#endif + + // Creates a deep copy of another optional + // Can throw if T::T(T const&) does + optional ( optional const& rhs ) : base(rhs) {} + + // No-throw (assuming T::~T() doesn't) + ~optional() {} + +#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION) + // Assigns from an expression. See corresponding constructor. + // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED + template + optional& operator= ( Expr expr ) + { + this->assign_expr(expr,&expr); + return *this ; + } +#endif + +#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT + // Assigns from another convertible optional (converts && deep-copies the rhs value) + // Requires a valid conversion from U to T. + // Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED + template + optional& operator= ( optional const& rhs ) + { + this->assign(rhs.get()); + return *this ; + } +#endif + + // Assigns from another optional (deep-copies the rhs value) + // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED + // (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw) + optional& operator= ( optional const& rhs ) + { + this->assign( rhs ) ; + return *this ; + } + + // Assigns from a T (deep-copies the rhs value) + // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED + optional& operator= ( argument_type val ) + { + this->assign( val ) ; + return *this ; + } + + // Assigns from a "none" + // Which destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + optional& operator= ( none_t const& none_ ) + { + this->assign( none_ ) ; + return *this ; + } + + // Returns a reference to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + reference_const_type get() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } + reference_type get() { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } + + // Returns a pointer to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + pointer_const_type operator->() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } + pointer_type operator->() { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } + + // Returns a reference to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + reference_const_type operator *() const { return this->get() ; } + reference_type operator *() { return this->get() ; } + + // implicit conversion to "bool" + // No-throw + operator unspecified_bool_type() const { return this->safe_bool() ; } + + // This is provided for those compilers which don't like the conversion to bool + // on some contexts. + bool operator!() const { return !this->is_initialized() ; } +} ; + +// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::reference_const_type +get ( optional const& opt ) +{ + return opt.get() ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::reference_type +get ( optional& opt ) +{ + return opt.get() ; +} + +// Returns a pointer to the value if this is initialized, otherwise, returns NULL. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_const_type +get ( optional const* opt ) +{ + return opt->get_ptr() ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_type +get ( optional* opt ) +{ + return opt->get_ptr() ; +} + +// Returns a pointer to the value if this is initialized, otherwise, returns NULL. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_const_type +get_pointer ( optional const& opt ) +{ + return opt.get_ptr() ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_type +get_pointer ( optional& opt ) +{ + return opt.get_ptr() ; +} + +// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values). +// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead. + +template +inline +bool operator == ( optional const& x, optional const& y ) +{ return equal_pointees(x,y); } + +template +inline +bool operator < ( optional const& x, optional const& y ) +{ return less_pointees(x,y); } + +template +inline +bool operator != ( optional const& x, optional const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( optional const& x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, optional const& y ) +{ return !( x < y ) ; } + +template +inline +bool operator == ( optional const& x, none_t const& ) +{ return equal_pointees(x, optional() ); } + +template +inline +bool operator < ( optional const& x, none_t const& ) +{ return less_pointees(x,optional() ); } + +template +inline +bool operator != ( optional const& x, none_t const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( optional const& x, none_t const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, none_t const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, none_t const& y ) +{ return !( x < y ) ; } + +template +inline +bool operator == ( none_t const& x, optional const& y ) +{ return equal_pointees(optional() ,y); } + +template +inline +bool operator < ( none_t const& x, optional const& y ) +{ return less_pointees(optional() ,y); } + +template +inline +bool operator != ( none_t const& x, optional const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( none_t const& x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( none_t const& x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( none_t const& x, optional const& y ) +{ return !( x < y ) ; } + +// +// The following swap implementation follows the GCC workaround as found in +// "boost/detail/compressed_pair.hpp" +// +namespace optional_detail { + +// GCC < 3.2 gets the using declaration at namespace scope (FLC, DWA) +#if BOOST_WORKAROUND(__GNUC__, < 3) \ + || BOOST_WORKAROUND(__GNUC__, == 3) && __GNUC_MINOR__ <= 2 + using std::swap; +#define BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE +#endif + +// optional's swap: +// If both are initialized, calls swap(T&, T&). If this swap throws, both will remain initialized but their values are now unspecified. +// If only one is initialized, calls U.reset(*I), THEN I.reset(). +// If U.reset(*I) throws, both are left UNCHANGED (U is kept uinitialized and I is never reset) +// If both are uninitialized, do nothing (no-throw) +template +inline +void optional_swap ( optional& x, optional& y ) +{ + if ( !x && !!y ) + { + x.reset(*y); + y.reset(); + } + else if ( !!x && !y ) + { + y.reset(*x); + x.reset(); + } + else if ( !!x && !!y ) + { +// GCC > 3.2 and all other compilers have the using declaration at function scope (FLC) +#ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE + // allow for Koenig lookup + using std::swap ; +#endif + swap(*x,*y); + } +} + +} // namespace optional_detail + +template inline void swap ( optional& x, optional& y ) +{ + optional_detail::optional_swap(x,y); +} + +} // namespace boost + +#endif + diff --git a/deal.II/contrib/boost/include/boost/optional/optional_fwd.hpp b/deal.II/contrib/boost/include/boost/optional/optional_fwd.hpp new file mode 100644 index 0000000000..2cf4fa654c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/optional/optional_fwd.hpp @@ -0,0 +1,22 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/lib/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP +#define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP + +namespace boost { + +template class optional ; + +} // namespace boost + +#endif + diff --git a/deal.II/contrib/boost/include/boost/pending/bucket_sorter.hpp b/deal.II/contrib/boost/include/boost/pending/bucket_sorter.hpp new file mode 100644 index 0000000000..8b7926d2df --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/bucket_sorter.hpp @@ -0,0 +1,134 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +//======================================================================= +// +// +// Revision History: +// 13 June 2001: Changed some names for clarity. (Jeremy Siek) +// 01 April 2001: Modified to use new header. (JMaddock) +// +#ifndef BOOST_GRAPH_DETAIL_BUCKET_SORTER_HPP +#define BOOST_GRAPH_DETAIL_BUCKET_SORTER_HPP + +#include +#include +#include + +namespace boost { + + template + class bucket_sorter { + public: + typedef BucketType bucket_type; + typedef ValueType value_type; + typedef typename std::vector::size_type size_type; + + bucket_sorter(size_type _length, bucket_type _max_bucket, + const Bucket& _bucket = Bucket(), + const ValueIndexMap& _id = ValueIndexMap()) + : head(_max_bucket, invalid_value()), + next(_length, invalid_value()), + prev(_length, invalid_value()), + id_to_value(_length), + bucket(_bucket), id(_id) { } + + void remove(const value_type& x) { + const size_type i = get(id, x); + const size_type& next_node = next[i]; + const size_type& prev_node = prev[i]; + + //check if i is the end of the bucket list + if ( next_node != invalid_value() ) + prev[next_node] = prev_node; + //check if i is the begin of the bucket list + if ( prev_node != invalid_value() ) + next[prev_node] = next_node; + else //need update head of current bucket list + head[ bucket[x] ] = next_node; + } + + void push(const value_type& x) { + id_to_value[get(id, x)] = x; + (*this)[bucket[x]].push(x); + } + + void update(const value_type& x) { + remove(x); + (*this)[bucket[x]].push(x); + } + // private: + // with KCC, the nested stack class is having access problems + // despite the friend decl. + static size_type invalid_value() { + return (std::numeric_limits::max)(); + } + + typedef typename std::vector::iterator Iter; + typedef typename std::vector::iterator IndexValueMap; + + public: + friend class stack; + + class stack { + public: + stack(bucket_type _bucket_id, Iter h, Iter n, Iter p, IndexValueMap v, + const ValueIndexMap& _id) + : bucket_id(_bucket_id), head(h), next(n), prev(p), value(v), id(_id) {} + + // Avoid using default arg for ValueIndexMap so that the default + // constructor of the ValueIndexMap is not required if not used. + stack(bucket_type _bucket_id, Iter h, Iter n, Iter p, IndexValueMap v) + : bucket_id(_bucket_id), head(h), next(n), prev(p), value(v) {} + + void push(const value_type& x) { + const size_type new_head = get(id, x); + const size_type current = head[bucket_id]; + if ( current != invalid_value() ) + prev[current] = new_head; + prev[new_head] = invalid_value(); + next[new_head] = current; + head[bucket_id] = new_head; + } + void pop() { + size_type current = head[bucket_id]; + size_type next_node = next[current]; + head[bucket_id] = next_node; + if ( next_node != invalid_value() ) + prev[next_node] = invalid_value(); + } + value_type& top() { return value[ head[bucket_id] ]; } + const value_type& top() const { return value[ head[bucket_id] ]; } + bool empty() const { return head[bucket_id] == invalid_value(); } + private: + bucket_type bucket_id; + Iter head; + Iter next; + Iter prev; + IndexValueMap value; + ValueIndexMap id; + }; + + stack operator[](const bucket_type& i) { + assert(i < head.size()); + return stack(i, head.begin(), next.begin(), prev.begin(), + id_to_value.begin(), id); + } + protected: + std::vector head; + std::vector next; + std::vector prev; + std::vector id_to_value; + Bucket bucket; + ValueIndexMap id; + }; + +} + +#endif diff --git a/deal.II/contrib/boost/include/boost/pending/container_traits.hpp b/deal.II/contrib/boost/include/boost/pending/container_traits.hpp new file mode 100644 index 0000000000..9b0760b5d0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/container_traits.hpp @@ -0,0 +1,399 @@ +// (C) Copyright Jeremy Siek 2004 +// 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_GRAPH_DETAIL_CONTAINER_TRAITS_H +#define BOOST_GRAPH_DETAIL_CONTAINER_TRAITS_H + +// Sure would be nice to be able to forward declare these +// instead of pulling in all the headers. Too bad that +// is not legal. There ought to be a standard header. -JGS + +#include + +#include // for std::remove +#include +#include +#include +#include +#ifndef BOOST_NO_SLIST +# include +#endif +#ifndef BOOST_NO_HASH +# include +# include +#endif + +// The content of this file is in 'graph_detail' because otherwise +// there will be name clashes with +// sandbox/boost/sequence_algo/container_traits.hpp +// The 'detail' subnamespace will still cause problems. +namespace boost { namespace graph_detail { + + //====================================================================== + // Container Category Tags + // + // They use virtual inheritance because there are lots of + // inheritance diamonds. + + struct container_tag { }; + struct forward_container_tag : virtual public container_tag { }; + struct reversible_container_tag : virtual public forward_container_tag { }; + struct random_access_container_tag + : virtual public reversible_container_tag { }; + + struct sequence_tag : virtual public forward_container_tag { }; + + struct associative_container_tag : virtual public forward_container_tag { }; + + struct sorted_associative_container_tag + : virtual public associative_container_tag, + virtual public reversible_container_tag { }; + + struct front_insertion_sequence_tag : virtual public sequence_tag { }; + struct back_insertion_sequence_tag : virtual public sequence_tag { }; + + struct unique_associative_container_tag + : virtual public associative_container_tag { }; + struct multiple_associative_container_tag + : virtual public associative_container_tag { }; + struct simple_associative_container_tag + : virtual public associative_container_tag { }; + struct pair_associative_container_tag + : virtual public associative_container_tag { }; + + + //====================================================================== + // Iterator Stability Tags + // + // Do mutating operations such as insert/erase/resize invalidate all + // outstanding iterators? + + struct stable_tag { }; + struct unstable_tag { }; + + //====================================================================== + // Container Traits Class and container_category() function + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + // don't use this unless there is partial specialization + template + struct container_traits { + typedef typename Container::category category; + typedef typename Container::iterator_stability iterator_stability; + }; +#endif + + // Use this as a compile-time assertion that X is stable + inline void require_stable(stable_tag) { } + + // std::vector + struct vector_tag : + virtual public random_access_container_tag, + virtual public back_insertion_sequence_tag { }; + + template + vector_tag container_category(const std::vector&) + { return vector_tag(); } + + template + unstable_tag iterator_stability(const std::vector&) + { return unstable_tag(); } + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< std::vector > { + typedef vector_tag category; + typedef unstable_tag iterator_stability; + }; +#endif + + // std::list + struct list_tag : + virtual public reversible_container_tag, + virtual public back_insertion_sequence_tag + // this causes problems for push_dispatch... + // virtual public front_insertion_sequence_tag + { }; + + template + list_tag container_category(const std::list&) + { return list_tag(); } + + template + stable_tag iterator_stability(const std::list&) + { return stable_tag(); } + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< std::list > { + typedef list_tag category; + typedef stable_tag iterator_stability; + }; +#endif + + + // std::slist +#ifndef BOOST_NO_SLIST +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits > { + typedef front_insertion_sequence_tag category; + typedef stable_tag iterator_stability; + }; +#endif + template + front_insertion_sequence_tag container_category( + const BOOST_STD_EXTENSION_NAMESPACE::slist& + ) + { return front_insertion_sequence_tag(); } + + template + stable_tag iterator_stability( + const BOOST_STD_EXTENSION_NAMESPACE::slist&) + { return stable_tag(); } +#endif + + + // std::set + struct set_tag : + virtual public sorted_associative_container_tag, + virtual public simple_associative_container_tag, + virtual public unique_associative_container_tag + { }; + + template + set_tag container_category(const std::set&) + { return set_tag(); } + + template + stable_tag iterator_stability(const std::set&) + { return stable_tag(); } + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< std::set > { + typedef set_tag category; + typedef stable_tag iterator_stability; + }; +#endif + + // std::multiset + struct multiset_tag : + virtual public sorted_associative_container_tag, + virtual public simple_associative_container_tag, + virtual public multiple_associative_container_tag + { }; + + template + multiset_tag container_category(const std::multiset&) + { return multiset_tag(); } + + template + stable_tag iterator_stability(const std::multiset&) + { return stable_tag(); } + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< std::multiset > { + typedef multiset_tag category; + typedef stable_tag iterator_stability; + }; +#endif + + // deque + + // std::map + struct map_tag : + virtual public sorted_associative_container_tag, + virtual public pair_associative_container_tag, + virtual public unique_associative_container_tag + { }; + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< std::map > { + typedef map_tag category; + typedef stable_tag iterator_stability; + }; +#endif + + template + map_tag container_category(const std::map&) + { return map_tag(); } + + template + stable_tag iterator_stability(const std::map&) + { return stable_tag(); } + + // std::multimap + struct multimap_tag : + virtual public sorted_associative_container_tag, + virtual public pair_associative_container_tag, + virtual public multiple_associative_container_tag + { }; + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< std::multimap > { + typedef multimap_tag category; + typedef stable_tag iterator_stability; + }; +#endif + + template + multimap_tag container_category(const std::multimap&) + { return multimap_tag(); } + + template + stable_tag iterator_stability(const std::multimap&) + { return stable_tag(); } + + + // hash_set, hash_map + +#ifndef BOOST_NO_HASH +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct container_traits< BOOST_STD_EXTENSION_NAMESPACE::hash_set > { + typedef set_tag category; + typedef stable_tag iterator_stability; // is this right? + }; + template + struct container_traits< BOOST_STD_EXTENSION_NAMESPACE::hash_map > { + typedef map_tag category; + typedef stable_tag iterator_stability; // is this right? + }; +#endif + template + set_tag container_category(const BOOST_STD_EXTENSION_NAMESPACE::hash_set&) + { return set_tag(); } + + template + map_tag container_category(const BOOST_STD_EXTENSION_NAMESPACE::hash_map&) + { return map_tag(); } + + template + stable_tag iterator_stability(const BOOST_STD_EXTENSION_NAMESPACE::hash_set&) + { return stable_tag(); } + + template + stable_tag iterator_stability(const BOOST_STD_EXTENSION_NAMESPACE::hash_map&) + { return stable_tag(); } +#endif + + + + //=========================================================================== + // Generalized Container Functions + + + // Erase + template + void erase_dispatch(Sequence& c, const T& x, + sequence_tag) + { + c.erase(std::remove(c.begin(), c.end(), x), c.end()); + } + + template + void erase_dispatch(AssociativeContainer& c, const T& x, + associative_container_tag) + { + c.erase(x); + } + template + void erase(Container& c, const T& x) + { + erase_dispatch(c, x, container_category(c)); + } + + // Erase If + template + void erase_if_dispatch(Sequence& c, Predicate p, + sequence_tag, IteratorStability) + { +#if 0 + c.erase(std::remove_if(c.begin(), c.end(), p), c.end()); +#else + if (! c.empty()) + c.erase(std::remove_if(c.begin(), c.end(), p), c.end()); +#endif + } + template + void erase_if_dispatch(AssociativeContainer& c, Predicate p, + associative_container_tag, stable_tag) + { + typename AssociativeContainer::iterator i, next; + for (i = next = c.begin(); next != c.end(); i = next) { + ++next; + if (p(*i)) + c.erase(i); + } + } + template + void erase_if_dispatch(AssociativeContainer& c, Predicate p, + associative_container_tag, unstable_tag) + { + // This method is really slow, so hopefully we won't have any + // associative containers with unstable iterators! + // Is there a better way to do this? + typename AssociativeContainer::iterator i; + typename AssociativeContainer::size_type n = c.size(); + while (n--) + for (i = c.begin(); i != c.end(); ++i) + if (p(*i)) { + c.erase(i); + break; + } + } + template + void erase_if(Container& c, Predicate p) + { + erase_if_dispatch(c, p, container_category(c), iterator_stability(c)); + } + + // Push + template + std::pair + push_dispatch(Container& c, const T& v, back_insertion_sequence_tag) + { + c.push_back(v); + return std::make_pair(boost::prior(c.end()), true); + } + + template + std::pair + push_dispatch(Container& c, const T& v, front_insertion_sequence_tag) + { + c.push_front(v); + return std::make_pair(c.begin(), true); + } + + template + std::pair + push_dispatch(AssociativeContainer& c, const T& v, + unique_associative_container_tag) + { + return c.insert(v); + } + + template + std::pair + push_dispatch(AssociativeContainer& c, const T& v, + multiple_associative_container_tag) + { + return std::make_pair(c.insert(v), true); + } + + template + std::pair + push(Container& c, const T& v) + { + return push_dispatch(c, v, container_category(c)); + } + +}} // namespace boost::graph_detail + +#endif // BOOST_GRAPH_DETAIL_CONTAINER_TRAITS_H diff --git a/deal.II/contrib/boost/include/boost/pending/cstddef.hpp b/deal.II/contrib/boost/include/boost/pending/cstddef.hpp new file mode 100644 index 0000000000..440629e265 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/cstddef.hpp @@ -0,0 +1,16 @@ +// -*- C++ -*- forwarding header. +// (C) Copyright Jeremy Siek 2004 +// 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_CSTDDEF_HPP +#define BOOST_CSTDDEF_HPP + +#if defined(__sgi) && !defined(__GNUC__) +# include +#else +# include +#endif + +#endif diff --git a/deal.II/contrib/boost/include/boost/pending/ct_if.hpp b/deal.II/contrib/boost/include/boost/pending/ct_if.hpp new file mode 100644 index 0000000000..2f8540d893 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/ct_if.hpp @@ -0,0 +1,111 @@ +// (C) Copyright Jeremy Siek 2000. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// The ct_if implementation that avoids partial specialization is +// based on the IF class by Ulrich W. Eisenecker and Krzysztof +// Czarnecki. + +#ifndef BOOST_CT_IF_HPP +#define BOOST_CT_IF_HPP + +#include + +/* + There is a bug in the Borland compiler with regards to using + integers to specialize templates. This made it hard to use ct_if in + the graph library. Changing from 'ct_if' to 'ct_if_t' fixed the + problem. +*/ + +#include // true_type and false_type + +namespace boost { + + struct ct_if_error { }; + + template + struct ct_and { typedef false_type type; }; + template <> struct ct_and { typedef true_type type; }; + + template struct ct_not { typedef ct_if_error type; }; + template <> struct ct_not { typedef false_type type; }; + template <> struct ct_not { typedef true_type type; }; + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// agurt, 15/sep/02: in certain cases Borland has problems with +// choosing the right 'ct_if' specialization even though 'cond' +// _does_ equal '1'; the easiest way to fix it is to make first +// 'ct_if' non-type template parameter boolean. +#if !defined(__BORLANDC__) + template + struct ct_if { typedef ct_if_error type; }; + template + struct ct_if { typedef A type; }; + template + struct ct_if { typedef B type; }; +#else + template + struct ct_if { typedef A type; }; + template + struct ct_if { typedef B type; }; +#endif + + template + struct ct_if_t { typedef ct_if_error type; }; + template + struct ct_if_t { typedef A type; }; + template + struct ct_if_t { typedef B type; }; + +#else + + namespace detail { + + template struct IF; + template struct SlectSelector; + struct SelectFirstType; + struct SelectSecondType; + + struct SelectFirstType { + template + struct Template { typedef A type; }; + }; + + struct SelectSecondType { + template + struct Template { typedef B type; }; + }; + + template + struct SlectSelector { + typedef SelectFirstType type; + }; + + template <> + struct SlectSelector<0> { + typedef SelectSecondType type; + }; + + } // namespace detail + + template + struct ct_if + { + typedef typename detail::SlectSelector::type Selector; + typedef typename Selector::template Template::type type; + }; + + template + struct ct_if_t { + typedef typename ct_if::type type; + }; + +#endif + +} // namespace boost + +#endif // BOOST_CT_IF_HPP + diff --git a/deal.II/contrib/boost/include/boost/pending/detail/disjoint_sets.hpp b/deal.II/contrib/boost/include/boost/pending/detail/disjoint_sets.hpp new file mode 100644 index 0000000000..6d1ec3ac7e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/detail/disjoint_sets.hpp @@ -0,0 +1,88 @@ +// (C) Copyright Jeremy Siek 2004 +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_DISJOINT_SETS_HPP +#define BOOST_DETAIL_DISJOINT_SETS_HPP + +namespace boost { + +namespace detail { + +template +Vertex +find_representative_with_path_halving(ParentPA p, Vertex v) +{ + Vertex parent = get(p, v); + Vertex grandparent = get(p, parent); + while (parent != grandparent) { + put(p, v, grandparent); + v = grandparent; + parent = get(p, v); + grandparent = get(p, parent); + } + return parent; +} + +template +Vertex +find_representative_with_full_compression(ParentPA parent, Vertex v) +{ + Vertex old = v; + Vertex ancestor = get(parent, v); + while (ancestor != v) { + v = ancestor; + ancestor = get(parent, v); + } + v = get(parent, old); + while (ancestor != v) { + put(parent, old, ancestor); + old = v; + v = get(parent, old); + } + return ancestor; +} + +/* the postcondition of link sets is: + component_representative(i) == component_representative(j) + */ +template +inline void +link_sets(ParentPA p, RankPA rank, Vertex i, Vertex j, + ComponentRepresentative comp_rep) +{ + i = comp_rep(p, i); + j = comp_rep(p, j); + if (i == j) return; + if (get(rank, i) > get(rank, j)) + put(p, j, i); + else { + put(p, i, j); + if (get(rank, i) == get(rank, j)) + put(rank, j, get(rank, j) + 1); + } +} + +// normalize components has the following postcondidition: +// i >= p[i] +// that is, the representative is the node with the smallest index in its class +// as its precondition it it assumes that the node container is compressed + +template +inline void +normalize_node(ParentPA p, Vertex i) +{ + if (i > get(p,i) || get(p, get(p,i)) != get(p,i)) + put(p,i, get(p, get(p,i))); + else { + put(p, get(p,i), i); + put(p, i, i); + } +} + + } // namespace detail +} // namespace boost + +#endif // BOOST_DETAIL_DISJOINT_SETS_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/detail/int_iterator.hpp b/deal.II/contrib/boost/include/boost/pending/detail/int_iterator.hpp new file mode 100644 index 0000000000..e3bae34ce7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/detail/int_iterator.hpp @@ -0,0 +1,74 @@ +// (C) Copyright Jeremy Siek 1999. +// 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_INT_ITERATOR_H +#define BOOST_INT_ITERATOR_H + +#include +#if !defined BOOST_MSVC +#include +#endif +#include +//using namespace std; + +#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE +namespace boost { +#endif + +// this should use random_access_iterator_helper but I've had +// VC++ portablility problems with that. -JGS +template +class int_iterator +{ + typedef int_iterator self; +public: + typedef std::random_access_iterator_tag iterator_category; + typedef IntT value_type; + typedef IntT& reference; + typedef IntT* pointer; + typedef std::ptrdiff_t difference_type; + + inline int_iterator() : _i(0) { } + inline int_iterator(IntT i) : _i(i) { } + inline int_iterator(const self& x) : _i(x._i) { } + inline self& operator=(const self& x) { _i = x._i; return *this; } + inline IntT operator*() { return _i; } + inline IntT operator[](IntT n) { return _i + n; } + inline self& operator++() { ++_i; return *this; } + inline self operator++(int) { self t = *this; ++_i; return t; } + inline self& operator+=(IntT n) { _i += n; return *this; } + inline self operator+(IntT n) { self t = *this; t += n; return t; } + inline self& operator--() { --_i; return *this; } + inline self operator--(int) { self t = *this; --_i; return t; } + inline self& operator-=(IntT n) { _i -= n; return *this; } + inline IntT operator-(const self& x) const { return _i - x._i; } + inline bool operator==(const self& x) const { return _i == x._i; } + // vc++ had a problem finding != in random_access_iterator_helper + // need to look into this... for now implementing everything here -JGS + inline bool operator!=(const self& x) const { return _i != x._i; } + inline bool operator<(const self& x) const { return _i < x._i; } + inline bool operator<=(const self& x) const { return _i <= x._i; } + inline bool operator>(const self& x) const { return _i > x._i; } + inline bool operator>=(const self& x) const { return _i >= x._i; } +protected: + IntT _i; +}; + +template +inline int_iterator +operator+(IntT n, int_iterator t) { t += n; return t; } + +#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE +} /* namespace boost */ +#endif + +#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE +namespace boost { + using ::int_iterator; +} +#endif + + +#endif /* BOOST_INT_ITERATOR_H */ diff --git a/deal.II/contrib/boost/include/boost/pending/detail/property.hpp b/deal.II/contrib/boost/include/boost/pending/detail/property.hpp new file mode 100644 index 0000000000..09e8866cf6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/detail/property.hpp @@ -0,0 +1,160 @@ +// (C) Copyright Jeremy Siek 2004 +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_PROPERTY_HPP +#define BOOST_DETAIL_PROPERTY_HPP + +#include // for std::pair +#include // for is_same + +namespace boost { + + namespace detail { + + template + struct same_property { + enum { value = is_same::value }; + }; + + struct error_property_not_found { }; + + template + struct property_value_dispatch { + template + inline static T& get_value(PropertyTag& p, T*, Tag) { + return p.m_value; + } + template + inline static const T& const_get_value(const PropertyTag& p, T*, Tag) { + return p.m_value; + } + }; + + template + struct property_value_end { + template struct result { typedef T type; }; + + template + inline static T& get_value(PropertyList& p, T* t, Tag tag) { + typedef typename PropertyList::next_type Next; + typedef typename Next::tag_type Next_tag; + enum { match = same_property::value }; + return property_value_dispatch + ::get_value(static_cast(p), t, tag); + } + template + inline static const T& const_get_value(const PropertyList& p, T* t, Tag tag) { + typedef typename PropertyList::next_type Next; + typedef typename Next::tag_type Next_tag; + enum { match = same_property::value }; + return property_value_dispatch + ::const_get_value(static_cast(p), t, tag); + } + }; + template <> + struct property_value_end { + template struct result { + typedef detail::error_property_not_found type; + }; + + // Stop the recursion and return error + template + inline static detail::error_property_not_found& + get_value(no_property&, T*, Tag) { + static error_property_not_found s_prop_not_found; + return s_prop_not_found; + } + template + inline static const detail::error_property_not_found& + const_get_value(const no_property&, T*, Tag) { + static error_property_not_found s_prop_not_found; + return s_prop_not_found; + } + }; + + template <> + struct property_value_dispatch<0> { + template + inline static typename property_value_end::template result::type& + get_value(PropertyList& p, T* t, Tag tag) { + return property_value_end::get_value(p, t, tag); + } + template + inline static const typename property_value_end::template result::type& + const_get_value(const PropertyList& p, T* t, Tag tag) { + return property_value_end::const_get_value(p, t, tag); + } + }; + + template + struct build_property_tag_value_alist + { + typedef typename PropertyList::next_type NextProperty; + typedef typename PropertyList::value_type Value; + typedef typename PropertyList::tag_type Tag; + typedef typename build_property_tag_value_alist::type Next; + typedef std::pair< std::pair, Next> type; + }; + template <> + struct build_property_tag_value_alist + { + typedef no_property type; + }; + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct extract_value { + typedef error_property_not_found type; + }; + template + struct extract_value< std::pair,Rest>, Tag2> { + typedef typename extract_value::type type; + }; + template + struct extract_value< std::pair,Rest>, Tag> { + typedef Value type; + }; +#else + // VC++ workaround: + // The main idea here is to replace partial specialization with + // nested template member classes. Of course there is the + // further complication that the outer class of the nested + // template class cannot itself be a template class. + // Hence the need for the ev_selector. -JGS + + struct recursive_extract; + struct end_extract; + + template + struct ev_selector { typedef recursive_extract type; }; + template <> + struct ev_selector { typedef end_extract type; }; + + struct recursive_extract { + template + struct bind_ { + typedef typename TagValueAList::first_type AListFirst; + typedef typename AListFirst::first_type Tag2; + typedef typename AListFirst::second_type Value; + enum { match = same_property::value }; + typedef typename TagValueAList::second_type Next; + typedef typename ev_selector::type Extractor; + typedef typename boost::ct_if< match, Value, + typename Extractor::template bind_::type + >::type type; + }; + }; + struct end_extract { + template + struct bind_ { + typedef error_property_not_found type; + }; + }; +#endif //!defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + } // namespace detail +} // namespace boost + +#endif // BOOST_DETAIL_PROPERTY_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/disjoint_sets.hpp b/deal.II/contrib/boost/include/boost/pending/disjoint_sets.hpp new file mode 100644 index 0000000000..e64bc2b713 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/disjoint_sets.hpp @@ -0,0 +1,220 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_DISJOINT_SETS_HPP +#define BOOST_DISJOINT_SETS_HPP + +#include +#include +#include + +namespace boost { + + struct find_with_path_halving { + template + Vertex operator()(ParentPA p, Vertex v) { + return detail::find_representative_with_path_halving(p, v); + } + }; + + struct find_with_full_path_compression { + template + Vertex operator()(ParentPA p, Vertex v){ + return detail::find_representative_with_full_compression(p, v); + } + }; + + // This is a generalized functor to provide disjoint sets operations + // with "union by rank" and "path compression". A disjoint-set data + // structure maintains a collection S={S1, S2, ..., Sk} of disjoint + // sets. Each set is identified by a representative, which is some + // member of of the set. Sets are represented by rooted trees. Two + // heuristics: "union by rank" and "path compression" are used to + // speed up the operations. + + // Disjoint Set requires two vertex properties for internal use. A + // RankPA and a ParentPA. The RankPA must map Vertex to some Integral type + // (preferably the size_type associated with Vertex). The ParentPA + // must map Vertex to Vertex. + template + class disjoint_sets { + typedef disjoint_sets self; + + inline disjoint_sets() {} + public: + inline disjoint_sets(RankPA r, ParentPA p) + : rank(r), parent(p) {} + + inline disjoint_sets(const self& c) + : rank(c.rank), parent(c.parent) {} + + // Make Set -- Create a singleton set containing vertex x + template + inline void make_set(Element x) + { + put(parent, x, x); + typedef typename property_traits::value_type R; + put(rank, x, R()); + } + + // Link - union the two sets represented by vertex x and y + template + inline void link(Element x, Element y) + { + detail::link_sets(parent, rank, x, y, rep); + } + + // Union-Set - union the two sets containing vertex x and y + template + inline void union_set(Element x, Element y) + { + link(find_set(x), find_set(y)); + } + + // Find-Set - returns the Element representative of the set + // containing Element x and applies path compression. + template + inline Element find_set(Element x) + { + return rep(parent, x); + } + + template + inline std::size_t count_sets(ElementIterator first, ElementIterator last) + { + std::size_t count = 0; + for ( ; first != last; ++first) + if (get(parent, *first) == *first) + ++count; + return count; + } + + template + inline void normalize_sets(ElementIterator first, ElementIterator last) + { + for (; first != last; ++first) + detail::normalize_node(parent, *first); + } + + template + inline void compress_sets(ElementIterator first, ElementIterator last) + { + for (; first != last; ++first) + detail::find_representative_with_full_compression(parent, *first); + } + protected: + RankPA rank; + ParentPA parent; + FindCompress rep; + }; + + + + + template + class disjoint_sets_with_storage + { + typedef typename property_traits::value_type Index; + typedef std::vector ParentContainer; + typedef std::vector RankContainer; + public: + typedef typename ParentContainer::size_type size_type; + + disjoint_sets_with_storage(size_type n = 0, + ID id_ = ID(), + InverseID inv = InverseID()) + : id(id_), id_to_vertex(inv), rank(n, 0), parent(n) + { + for (Index i = 0; i < n; ++i) + parent[i] = i; + } + // note this is not normally needed + template + inline void + make_set(Element x) { + parent[x] = x; + rank[x] = 0; + } + template + inline void + link(Element x, Element y) + { + extend_sets(x,y); + detail::link_sets(&parent[0], &rank[0], + get(id,x), get(id,y), rep); + } + template + inline void + union_set(Element x, Element y) { + Element rx = find_set(x); + Element ry = find_set(y); + link(rx, ry); + } + template + inline Element find_set(Element x) { + return id_to_vertex[rep(&parent[0], get(id,x))]; + } + + template + inline std::size_t count_sets(ElementIterator first, ElementIterator last) + { + std::size_t count = 0; + for ( ; first != last; ++first) + if (parent[*first] == *first) + ++count; + return count; + } + + template + inline void normalize_sets(ElementIterator first, ElementIterator last) + { + for (; first != last; ++first) + detail::normalize_node(&parent[0], *first); + } + + template + inline void compress_sets(ElementIterator first, ElementIterator last) + { + for (; first != last; ++first) + detail::find_representative_with_full_compression(&parent[0], + *first); + } + + const ParentContainer& parents() { return parent; } + + protected: + + template + inline void + extend_sets(Element x, Element y) + { + Index needed = get(id,x) > get(id,y) ? get(id,x) + 1 : get(id,y) + 1; + if (needed > parent.size()) { + rank.insert(rank.end(), needed - rank.size(), 0); + for (Index k = parent.size(); k < needed; ++k) + parent.push_back(k); + } + } + + ID id; + InverseID id_to_vertex; + RankContainer rank; + ParentContainer parent; + FindCompress rep; + }; + +} // namespace boost + +#endif // BOOST_DISJOINT_SETS_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/fenced_priority_queue.hpp b/deal.II/contrib/boost/include/boost/pending/fenced_priority_queue.hpp new file mode 100644 index 0000000000..4d4e3aff94 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/fenced_priority_queue.hpp @@ -0,0 +1,152 @@ +// (C) Copyright Jeremiah Willcock 2004 +// 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_FENCED_PRIORITY_QUEUE_HPP +#define BOOST_FENCED_PRIORITY_QUEUE_HPP + +#include +#include +#include +#include + +// Fenced priority queue +// Jeremiah Willcock + +// This class implements a fenced priority queue. This is similar to +// a normal priority queue (sorts its members, and only returns the +// first), except that members cannot be sorted around a "fence" that +// can be placed into the buffer. This fence is inserted using the +// fence() member function or (possibly) implicitly by the top() and +// pop() methods, and is removed automatically when the elements +// around it are popped. + +// The implementation is as follows: Q is an unsorted queue that +// contains the already-sorted list data, and PQ is a priority queue +// that contains new elements (since the last fence) that have yet to +// be sorted. New elements are inserted into PQ, and a fence moves +// all elements in PQ into the back of Q in sorted order. Elements +// are then popped from the front of Q, and if that is empty the front +// of PQ. + +namespace boost { + + template, bool implicit_fence = true, + class Buffer = boost::queue > + class fenced_priority_queue { + public: + typedef T value_type; + typedef typename Buffer::size_type size_type; + + fenced_priority_queue(const Compare _comp = Compare() ) + : PQ(_comp) {} + + void push(const T& data); + void pop(void); + T& top(void); + const T& top(void) const; + size_type size(void) const; + bool empty(void) const; + void fence(void); + + private: + void fence(void) const; + + //let them mutable to allow const version of top and the same + //semantics with non-constant version. Rich Lee + mutable std::priority_queue, Compare> PQ; + mutable Buffer Q; + }; + + template + inline void + fenced_priority_queue:: + push(const T &t) { + // Push a new element after the last fence. This puts it into the + // priority queue to be sorted with all other elements in its + // partition. + PQ.push(t); + } + + template + inline void fenced_priority_queue:: + pop(void) { + // Pop one element from the front of the queue. Removes from the + // already-sorted part of the queue if it is non-empty, otherwise + // removes from the new-element priority queue. Runs an implicit + // "fence" operation if the implicit_fence template argument is + // true. + if (implicit_fence) fence(); + if ( !Q.empty() ) + Q.pop(); + else + PQ.pop(); + } + + template + inline T& fenced_priority_queue:: + top(void) { + // Get the top element from the queue. This element comes from Q if + // possible, otherwise from PQ. Causes an implicit "fence" + // operation if the implicit_fence template argument is true. + if (implicit_fence) fence(); + if ( !Q.empty() ) + return Q.top(); + else + //std::priority_queue only have const version of top. Rich Lee + return const_cast(PQ.top()); + } + + template + inline const T& + fenced_priority_queue:: + top(void) const { + if (implicit_fence) fence(); + if ( !Q.empty() ) + return Q.top(); + else + return PQ.top(); + } + + template + inline typename fenced_priority_queue::size_type + fenced_priority_queue:: + size(void) const { + // Returns the size of the queue (both parts together). + return Q.size() + PQ.size(); + } + + template + inline bool + fenced_priority_queue:: + empty(void) const { + // Returns if the queue is empty, i.e. both parts are empty. + return Q.empty() && PQ.empty(); + } + + template + inline void + fenced_priority_queue:: + fence(void) { + // Perform a fence operation. Remove elements from PQ in sorted + // order and insert them in the back of Q. + while ( !PQ.empty() ) { + Q.push(PQ.top()); + PQ.pop(); + } + } + template + inline void + fenced_priority_queue:: + fence(void) const { + // Perform a fence operation. Remove elements from PQ in sorted + // order and insert them in the back of Q. + while ( !PQ.empty() ) { + Q.push(PQ.top()); + PQ.pop(); + } + } + +} +#endif /* BOOST_FENCED_PRIORITY_QUEUE_HPP */ diff --git a/deal.II/contrib/boost/include/boost/pending/fibonacci_heap.hpp b/deal.II/contrib/boost/include/boost/pending/fibonacci_heap.hpp new file mode 100644 index 0000000000..f63bf6d1c3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/fibonacci_heap.hpp @@ -0,0 +1,267 @@ +// (C) Copyright Jeremy Siek 2004. +// 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_FIBONACCI_HEAP_HPP +#define BOOST_FIBONACCI_HEAP_HPP + +#if defined(__sgi) && !defined(__GNUC__) +# include +#else +# include +#endif +#include +#include +#include +#include +#include + +// +// An adaptation of Knuth's Fibonacci heap implementation +// in "The Stanford Graph Base", pages 475-482. +// + +namespace boost { + + +template , + class ID = identity_property_map> +class fibonacci_heap +{ + typedef typename boost::property_traits::value_type size_type; + typedef T value_type; +protected: + typedef fibonacci_heap self; + typedef std::vector LinkVec; + typedef typename LinkVec::iterator LinkIter; +public: + + fibonacci_heap(size_type n, + const Compare& cmp, + const ID& id = identity_property_map()) + : _key(n), _left(n), _right(n), _p(n), _mark(n), _degree(n), + _n(0), _root(n), _id(id), _compare(cmp), _child(n), +#if defined(BOOST_MSVC) || defined(__ICL) // need a new macro? + new_roots(size_type(log(float(n))) + 5) { } +#else + new_roots(size_type(std::log(float(n))) + 5) { } +#endif + + // 33 + void push(const T& d) { + ++_n; + size_type v = get(_id, d); + _key[v] = d; + _p[v] = nil(); + _degree[v] = 0; + _mark[v] = false; + _child[v] = nil(); + if (_root == nil()) { + _root = _left[v] = _right[v] = v; + //std::cout << "root added" << std::endl; + } else { + size_type u = _left[_root]; + _left[v] = u; + _right[v] = _root; + _left[_root] = _right[u] = v; + if (_compare(d, _key[_root])) + _root = v; + //std::cout << "non-root node added" << std::endl; + } + } + T& top() { return _key[_root]; } + const T& top() const { return _key[_root]; } + + // 38 + void pop() { + --_n; + int h = -1; + size_type v, w; + if (_root != nil()) { + if (_degree[_root] == 0) { + v = _right[_root]; + } else { + w = _child[_root]; + v = _right[w]; + _right[w] = _right[_root]; + for (w = v; w != _right[_root]; w = _right[w]) + _p[w] = nil(); + } + while (v != _root) { + w = _right[v]; + add_tree_to_new_roots(v, new_roots.begin(), h); + v = w; + } + rebuild_root_list(new_roots.begin(), h); + } + } + // 39 + inline void add_tree_to_new_roots(size_type v, + LinkIter new_roots, + int& h) + { + int r; + size_type u; + r = _degree[v]; + while (1) { + if (h < r) { + do { + ++h; + new_roots[h] = (h == r ? v : nil()); + } while (h < r); + break; + } + if (new_roots[r] == nil()) { + new_roots[r] = v; + break; + } + u = new_roots[r]; + new_roots[r] = nil(); + if (_compare(_key[u], _key[v])) { + _degree[v] = r; + std::swap(u, v); + } + make_child(u, v, r); + ++r; + } + _degree[v] = r; + } + // 40 + void make_child(size_type u, size_type v, size_type r) { + if (r == 0) { + _child[v] = u; + _left[u] = u; + _right[u] = u; + } else { + size_type t = _child[v]; + _right[u] = _right[t]; + _left[u] = t; + _right[t] = u; + _left[_right[u]] = u; + } + } + // 41 + inline void rebuild_root_list(LinkIter new_roots, int& h) + { + size_type u, v, w; + if (h < 0) + _root = nil(); + else { + T d; + u = v = new_roots[h]; + d = _key[u]; + _root = u; + for (h--; h >= 0; --h) + if (new_roots[h] != nil()) { + w = new_roots[h]; + _left[w] = v; + _right[v] = w; + if (_compare(_key[w], d)) { + _root = w; + d = _key[w]; + } + v = w; + } + _right[v] = u; + _left[u] = v; + } + } + + // 34 + void update(const T& d) { + size_type v = get(_id, d); + assert(!_compare(_key[v], d)); + _key[v] = d; + size_type p = _p[v]; + if (p == nil()) { + if (_compare(d, _key[_root])) + _root = v; + } else if (_compare(d, _key[_root])) + while (1) { + size_type r = _degree[p]; + if (r >= 2) + remove_from_family(v, p); + insert_into_forest(v, d); + size_type pp = _p[p]; + if (pp == nil()) { + --_degree[p]; + break; + } + if (_mark[p] == false) { + _mark[p] = true; + break; + } else + --_degree[p]; + v = p; + p = pp; + } + } + + inline size_type size() const { return _n; } + inline bool empty() const { return _n == 0; } + + void print(std::ostream& os) { + if (_root != nil()) { + size_type i = _root; + do { + print_recur(i, os); + os << std::endl; + i = _right[i]; + } while (i != _root); + } + } + +protected: + // 35 + inline void remove_from_family(size_type v, size_type p) { + size_type u = _left[v]; + size_type w = _right[v]; + _right[u] = w; + _left[w] = u; + if (_child[p] == v) + _child[p] = w; + } + // 36 + inline void insert_into_forest(size_type v, const T& d) { + _p[v] = nil(); + size_type u = _left[_root]; + _left[v] = u; + _right[v] = _root; + _left[_root] = _right[u] = v; + if (_compare(d, _key[_root])) + _root = v; + } + + void print_recur(size_type x, std::ostream& os) { + if (x != nil()) { + os << x; + if (_child[x] != nil()) { + os << "("; + size_type i = _child[x]; + do { + print_recur(i, os); os << " "; + i = _right[i]; + } while (i != _child[x]); + os << ")"; + } + } + } + + size_type nil() const { return _left.size(); } + + std::vector _key; + LinkVec _left, _right, _p; + std::vector _mark; + LinkVec _degree; + size_type _n, _root; + ID _id; + Compare _compare; + LinkVec _child; + LinkVec new_roots; +}; + +} // namespace boost + + +#endif // BOOST_FIBONACCI_HEAP_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/indirect_cmp.hpp b/deal.II/contrib/boost/include/boost/pending/indirect_cmp.hpp new file mode 100644 index 0000000000..c97594933f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/indirect_cmp.hpp @@ -0,0 +1,86 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_INDIRECT_CMP_HPP +#define BOOST_INDIRECT_CMP_HPP + +#include +#include +#include + +namespace boost { + + //: indirect_cmp + // + // could also do this with compose_f_gx_hx, and the member binder... + // + //!category: functors + //!component: type + //!tparam: ReadablePropertyMap - a model of ReadablePropertyMap + //!definition: functor.h + template + class indirect_cmp { + public: + typedef typename boost::property_traits::value_type T; + typedef typename boost::property_traits::key_type K; + typedef K first_argument_type; + typedef K second_argument_type; + typedef T result_type; + inline indirect_cmp(const ReadablePropertyMap& df, const Compare& c = Compare()) + : d(df), cmp(c) { } + + template + inline bool + operator()(const A& u, const B& v) const { + T du = get(d, u), dv = get(d, v); + return cmp(du, dv); + } + protected: + ReadablePropertyMap d; + Compare cmp; + }; + + template + indirect_cmp + make_indirect_cmp(const Compare& cmp, ReadablePropertyMap pmap) { + indirect_cmp p(pmap, cmp); + return p; + } + + template + class indirect_pmap { + public: + typedef typename boost::property_traits::value_type T; + typedef typename boost::property_traits::key_type K; + typedef K argument_type; + typedef T result_type; + inline indirect_pmap(const ReadablePropertyMap& df) + : d(df) { } + + inline bool operator()(const K& u) const { + return get(d, u); + } + protected: + ReadablePropertyMap d; + }; + + template + indirect_pmap + make_indirect_pmap(ReadablePropertyMap pmap) { + indirect_pmap f(pmap); + return f; + } + + +} // namespace boost + + +#endif // GGCL_INDIRECT_CMP_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/integer_log2.hpp b/deal.II/contrib/boost/include/boost/pending/integer_log2.hpp new file mode 100644 index 0000000000..fd8e4465d1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/integer_log2.hpp @@ -0,0 +1,113 @@ +// ------------------------------------- +// integer_log2.hpp +// +// Gives the integer part of the logarithm, in base 2, of a +// given number. Behavior is undefined if the argument is <= 0. +// +// +// (C) Copyright Gennaro Prota 2003 - 2004. +// +// 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_INTEGER_LOG2_HPP_GP_20030301 +#define BOOST_INTEGER_LOG2_HPP_GP_20030301 + +#include +#include // actually used for Borland only +#include "boost/limits.hpp" +#include "boost/config.hpp" + + +namespace boost { + namespace detail { + + template + int integer_log2_impl(T x, int n) { + + int result = 0; + + while (x != 1) { + + const T t = x >> n; + if (t) { + result += n; + x = t; + } + n /= 2; + + } + + return result; + } + + + + // helper to find the maximum power of two + // less than p (more involved than necessary, + // to avoid PTS) + // + template + struct max_pow2_less { + + enum { c = 2*n < p }; + + BOOST_STATIC_CONSTANT(int, value = + c ? (max_pow2_less< c*p, 2*c*n>::value) : n); + + }; + + template <> + struct max_pow2_less<0, 0> { + + BOOST_STATIC_CONSTANT(int, value = 0); + }; + + // this template is here just for Borland :( + // we could simply rely on numeric_limits but sometimes + // Borland tries to use numeric_limits, because + // of its usual const-related problems in argument deduction + // - gps + template + struct width { + +#ifdef __BORLANDC__ + BOOST_STATIC_CONSTANT(int, value = sizeof(T) * CHAR_BIT); +#else + BOOST_STATIC_CONSTANT(int, value = (std::numeric_limits::digits)); +#endif + + }; + + } // detail + + + // --------- + // integer_log2 + // --------------- + // + template + int integer_log2(T x) { + + assert(x > 0); + + const int n = detail::max_pow2_less< + detail::width :: value, 4 + > :: value; + + return detail::integer_log2_impl(x, n); + + } + + + +} + + + +#endif // include guard diff --git a/deal.II/contrib/boost/include/boost/pending/integer_range.hpp b/deal.II/contrib/boost/include/boost/pending/integer_range.hpp new file mode 100644 index 0000000000..229cbd8880 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/integer_range.hpp @@ -0,0 +1,59 @@ +// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// Revision History: +// 04 Jan 2001 Factored counting_iterator stuff into +// boost/counting_iterator.hpp (David Abrahams) + +#ifndef BOOST_INTEGER_RANGE_HPP_ +#define BOOST_INTEGER_RANGE_HPP_ + +#include +#include +#include + +namespace boost { + +//============================================================================= +// Counting Iterator and Integer Range Class + +template +struct integer_range { + typedef counting_iterator iterator; + + typedef iterator const_iterator; + typedef IntegerType value_type; + typedef std::ptrdiff_t difference_type; + typedef IntegerType reference; + typedef IntegerType const_reference; + typedef const IntegerType* pointer; + typedef const IntegerType* const_pointer; + typedef IntegerType size_type; + + integer_range(IntegerType start, IntegerType finish) + : m_start(start), m_finish(finish) { } + + iterator begin() const { return iterator(m_start); } + iterator end() const { return iterator(m_finish); } + size_type size() const { return m_finish - m_start; } + bool empty() const { return m_finish == m_start; } + void swap(integer_range& x) { + std::swap(m_start, x.m_start); + std::swap(m_finish, x.m_finish); + } +protected: + IntegerType m_start, m_finish; +}; + +template +inline integer_range +make_integer_range(IntegerType first, IntegerType last) +{ + return integer_range(first, last); +} + +} // namespace boost + +#endif // BOOST_INTEGER_RANGE_HPP_ diff --git a/deal.II/contrib/boost/include/boost/pending/is_heap.hpp b/deal.II/contrib/boost/include/boost/pending/is_heap.hpp new file mode 100644 index 0000000000..b2e4b00694 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/is_heap.hpp @@ -0,0 +1,62 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +//======================================================================= +// +#if __KCC +namespace std { + +template +bool __is_heap(RandomAccessIterator first, RandomAccessIterator last, + Distance*) +{ + const Distance n = last - first; + + Distance parent = 0; + for (Distance child = 1; child < n; ++child) { + if (first[parent] < first[child]) + return false; + if ((child & 1) == 0) + ++parent; + } + return true; +} + +template +inline bool is_heap(RandomAccessIterator first, RandomAccessIterator last) +{ + return __is_heap(first, last, distance_type(first)); +} + + +template +bool __is_heap(RandomAccessIterator first, RandomAccessIterator last, + StrictWeakOrdering comp, + Distance*) +{ + const Distance n = last - first; + + Distance parent = 0; + for (Distance child = 1; child < n; ++child) { + if (comp(first[parent], first[child])) + return false; + if ((child & 1) == 0) + ++parent; + } + return true; +} + +template +inline bool is_heap(RandomAccessIterator first, RandomAccessIterator last, + StrictWeakOrdering comp) +{ + return __is_heap(first, last, comp, distance_type(first)); +} + +} +#endif diff --git a/deal.II/contrib/boost/include/boost/pending/iterator_adaptors.hpp b/deal.II/contrib/boost/include/boost/pending/iterator_adaptors.hpp new file mode 100644 index 0000000000..2256e81240 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/iterator_adaptors.hpp @@ -0,0 +1,6 @@ +// Copyright David Abrahams 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) + +#include diff --git a/deal.II/contrib/boost/include/boost/pending/iterator_tests.hpp b/deal.II/contrib/boost/include/boost/pending/iterator_tests.hpp new file mode 100644 index 0000000000..dd5fe2ddd6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/iterator_tests.hpp @@ -0,0 +1,268 @@ +// Copyright David Abrahams and Jeremy Siek 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) +#ifndef BOOST_ITERATOR_TESTS_HPP +# define BOOST_ITERATOR_TESTS_HPP + +// This is meant to be the beginnings of a comprehensive, generic +// test suite for STL concepts such as iterators and containers. +// +// Revision History: +// 28 Apr 2002 Fixed input iterator requirements. +// For a == b a++ == b++ is no longer required. +// See 24.1.1/3 for details. +// (Thomas Witt) +// 08 Feb 2001 Fixed bidirectional iterator test so that +// --i is no longer a precondition. +// (Jeremy Siek) +// 04 Feb 2001 Added lvalue test, corrected preconditions +// (David Abrahams) + +# include +# include +# include +# include +# include // for detail::dummy_constructor +# include +# include + +namespace boost { + + // use this for the value type +struct dummyT { + dummyT() { } + dummyT(detail::dummy_constructor) { } + dummyT(int x) : m_x(x) { } + int foo() const { return m_x; } + bool operator==(const dummyT& d) const { return m_x == d.m_x; } + int m_x; +}; + +} + +BOOST_TT_BROKEN_COMPILER_SPEC(boost::dummyT) + +namespace boost { + +// Tests whether type Iterator satisfies the requirements for a +// TrivialIterator. +// Preconditions: i != j, *i == val +template +void trivial_iterator_test(const Iterator i, const Iterator j, T val) +{ + Iterator k; + assert(i == i); + assert(j == j); + assert(i != j); +#ifdef BOOST_NO_STD_ITERATOR_TRAITS + T v = *i; +#else + typename std::iterator_traits::value_type v = *i; +#endif + assert(v == val); +#if 0 + // hmm, this will give a warning for transform_iterator... perhaps + // this should be separated out into a stand-alone test since there + // are several situations where it can't be used, like for + // integer_range::iterator. + assert(v == i->foo()); +#endif + k = i; + assert(k == k); + assert(k == i); + assert(k != j); + assert(*k == val); +} + + +// Preconditions: i != j +template +void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val) +{ + *i = val; + trivial_iterator_test(i, j, val); +} + + +// Preconditions: *i == v1, *++i == v2 +template +void input_iterator_test(Iterator i, T v1, T v2) +{ + Iterator i1(i); + + assert(i == i1); + assert(!(i != i1)); + + // I can see no generic way to create an input iterator + // that is in the domain of== of i and != i. + // The following works for istream_iterator but is not + // guaranteed to work for arbitrary input iterators. + // + // Iterator i2; + // + // assert(i != i2); + // assert(!(i == i2)); + + assert(*i1 == v1); + assert(*i == v1); + + // we cannot test for equivalence of (void)++i & (void)i++ + // as i is only guaranteed to be single pass. + assert(*i++ == v1); + + i1 = i; + + assert(i == i1); + assert(!(i != i1)); + + assert(*i1 == v2); + assert(*i == v2); + + // i is dereferencable, so it must be incrementable. + ++i; + + // how to test for operator-> ? +} + +// how to test output iterator? + + +template struct lvalue_test +{ + template static void check(Iterator) + { +# ifndef BOOST_NO_STD_ITERATOR_TRAITS + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::value_type value_type; +# else + typedef typename Iterator::reference reference; + typedef typename Iterator::value_type value_type; +# endif + BOOST_STATIC_ASSERT(boost::is_reference::value); + BOOST_STATIC_ASSERT((boost::is_same::value + || boost::is_same::value + )); + } +}; + +# ifdef BOOST_NO_STD_ITERATOR_TRAITS +template <> struct lvalue_test { + template static void check(T) {} +}; +#endif + +template +void forward_iterator_test(Iterator i, T v1, T v2) +{ + input_iterator_test(i, v1, v2); + + Iterator i1 = i, i2 = i; + + assert(i == i1++); + assert(i != ++i2); + + trivial_iterator_test(i, i1, v1); + trivial_iterator_test(i, i2, v1); + + ++i; + assert(i == i1); + assert(i == i2); + ++i1; + ++i2; + + trivial_iterator_test(i, i1, v2); + trivial_iterator_test(i, i2, v2); + + // borland doesn't allow non-type template parameters +# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551) + lvalue_test<(boost::is_pointer::value)>::check(i); +#endif +} + +// Preconditions: *i == v1, *++i == v2 +template +void bidirectional_iterator_test(Iterator i, T v1, T v2) +{ + forward_iterator_test(i, v1, v2); + ++i; + + Iterator i1 = i, i2 = i; + + assert(i == i1--); + assert(i != --i2); + + trivial_iterator_test(i, i1, v2); + trivial_iterator_test(i, i2, v2); + + --i; + assert(i == i1); + assert(i == i2); + ++i1; + ++i2; + + trivial_iterator_test(i, i1, v1); + trivial_iterator_test(i, i2, v1); +} + +// mutable_bidirectional_iterator_test + +template struct undefined; + +// Preconditions: [i,i+N) is a valid range +template +void random_access_iterator_test(Iterator i, int N, TrueVals vals) +{ + bidirectional_iterator_test(i, vals[0], vals[1]); + const Iterator j = i; + int c; + + typedef typename boost::detail::iterator_traits::value_type value_type; + + for (c = 0; c < N-1; ++c) { + assert(i == j + c); + assert(*i == vals[c]); + assert(*i == boost::implicit_cast(j[c])); + assert(*i == *(j + c)); + assert(*i == *(c + j)); + ++i; + assert(i > j); + assert(i >= j); + assert(j <= i); + assert(j < i); + } + + Iterator k = j + N - 1; + for (c = 0; c < N-1; ++c) { + assert(i == k - c); + assert(*i == vals[N - 1 - c]); + assert(*i == boost::implicit_cast(j[N - 1 - c])); + Iterator q = k - c; + assert(*i == *q); + assert(i > j); + assert(i >= j); + assert(j <= i); + assert(j < i); + --i; + } +} + +// Precondition: i != j +template +void const_nonconst_iterator_test(Iterator i, ConstIterator j) +{ + assert(i != j); + assert(j != i); + + ConstIterator k(i); + assert(k == i); + assert(i == k); + + k = i; + assert(k == i); + assert(i == k); +} + +} // namespace boost + +#endif // BOOST_ITERATOR_TESTS_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/lowest_bit.hpp b/deal.II/contrib/boost/include/boost/pending/lowest_bit.hpp new file mode 100644 index 0000000000..dd8914e9f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/lowest_bit.hpp @@ -0,0 +1,39 @@ +// ------------------------------------- +// lowest_bit.hpp +// +// Position of the lowest bit 'on' +// +// (C) Copyright Gennaro Prota 2003 - 2004. +// +// 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_LOWEST_BIT_HPP_GP_20030301 +#define BOOST_LOWEST_BIT_HPP_GP_20030301 + +#include +#include "boost/pending/integer_log2.hpp" + + +namespace boost { + + template + int lowest_bit(T x) { + + assert(x >= 1); // PRE + + // clear all bits on except the rightmost one, + // then calculate the logarithm base 2 + // + return boost::integer_log2( x - ( x & (x-1) ) ); + + } + + +} + + +#endif // include guard diff --git a/deal.II/contrib/boost/include/boost/pending/mutable_heap.hpp b/deal.II/contrib/boost/include/boost/pending/mutable_heap.hpp new file mode 100644 index 0000000000..bbc8188190 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/mutable_heap.hpp @@ -0,0 +1,64 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_GRAPH_DETAIL_MUTABLE_HEAP_H +#define BOOST_GRAPH_DETAIL_MUTABLE_HEAP_H + +/* + There are a few things wrong with this set of functions. + + ExternalData should be removed, it is not part of the core + algorithm. It can be handled inside the tree nodes. + + The swap() should be replaced by assignment since its use is causing + the number of memory references to double. + + The min_element should be replaced by a fixed length loop + (fixed at d for d-heaps). + + The member functions of TreeNode should be changed to global + functions. + + These functions will be replaced by those in heap_tree.h + + */ + +namespace boost { + + template + inline TreeNode up_heap(TreeNode x, const Compare& comp, ExternalData& edata) { + while (x.has_parent() && comp(x, x.parent())) + x.swap(x.parent(), edata); + return x; + } + + template + inline TreeNode down_heap(TreeNode x, const Compare& comp, ExternalData& edata) { + while (x.children().size() > 0) { + typename TreeNode::children_type::iterator + child_iter = std::min_element(x.children().begin(), + x.children().end(), + comp); + if (comp(*child_iter, x)) + x.swap(*child_iter, edata); + else + break; + } + return x; + } + + template + inline void update_heap(TreeNode x, const Compare& comp, ExternalData& edata) { + x = down_heap(x, comp, edata); + (void)up_heap(x, comp, edata); + } + +} +#endif diff --git a/deal.II/contrib/boost/include/boost/pending/mutable_queue.hpp b/deal.II/contrib/boost/include/boost/pending/mutable_queue.hpp new file mode 100644 index 0000000000..b0f1073f12 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/mutable_queue.hpp @@ -0,0 +1,135 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// 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_MUTABLE_QUEUE_HPP +#define BOOST_MUTABLE_QUEUE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + + // The mutable queue whose elements are indexed + // + // This adaptor provides a special kind of priority queue that has + // and update operation. This allows the ordering of the items to + // change. After the ordering criteria for item x changes, one must + // call the Q.update(x) + // + // In order to efficiently find x in the queue, a functor must be + // provided to map value_type to a unique ID, which the + // mutable_queue will then use to map to the location of the + // item. The ID's generated must be between 0 and N, where N is the + // value passed to the constructor of mutable_queue + + template , + class Comp = std::less, + class ID = identity_property_map > + class mutable_queue { + public: + typedef IndexedType value_type; + typedef typename RandomAccessContainer::size_type size_type; + protected: + typedef typename RandomAccessContainer::iterator iterator; +#if !defined BOOST_NO_STD_ITERATOR_TRAITS + typedef adstl::array_binary_tree_node Node; +#else + typedef adstl::array_binary_tree_node Node; +#endif + typedef adstl::compare_array_node Compare; + typedef std::vector IndexArray; + public: + typedef Compare value_compare; + typedef ID id_generator; + + mutable_queue(size_type n, const Comp& x, const ID& _id) + : index_array(n), comp(x), id(_id) { + c.reserve(n); + } + template + mutable_queue(ForwardIterator first, ForwardIterator last, + const Comp& x, const ID& _id) + : index_array(std::distance(first, last)), comp(x), id(_id) + { + while( first != last ) { + push(*first); + ++first; + } + } + + bool empty() const { return c.empty(); } + + void pop() { + value_type tmp = c.back(); + c.back() = c.front(); + c.front() = tmp; + + size_type id_f = get(id, c.back()); + size_type id_b = get(id, tmp); + size_type i = index_array[ id_b ]; + index_array[ id_b ] = index_array[ id_f ]; + index_array[ id_f ] = i; + + c.pop_back(); + Node node(c.begin(), c.end(), c.begin(), id); + down_heap(node, comp, index_array); + } + void push(const IndexedType& x) { + c.push_back(x); + /*set index-array*/ + index_array[ get(id, x) ] = c.size()-1; + Node node(c.begin(), c.end(), c.end() - 1, id); + up_heap(node, comp, index_array); + } + + void update(const IndexedType& x) { + size_type current_pos = index_array[ get(id, x) ]; + c[current_pos] = x; + + Node node(c.begin(), c.end(), c.begin()+current_pos, id); + update_heap(node, comp, index_array); + } + + value_type& front() { return c.front(); } + value_type& top() { return c.front(); } + + const value_type& front() const { return c.front(); } + const value_type& top() const { return c.front(); } + + size_type size() const { return c.size(); } + + void clear() { c.clear(); } + +#if 0 + // dwa 2003/7/11 - I don't know what compiler is supposed to + // be able to compile this, but is_heap is not standard!! + bool test() { + return std::is_heap(c.begin(), c.end(), Comp()); + } +#endif + + protected: + IndexArray index_array; + Compare comp; + RandomAccessContainer c; + ID id; + }; + + +} + +#endif // BOOST_MUTABLE_QUEUE_HPP diff --git a/deal.II/contrib/boost/include/boost/pending/property.hpp b/deal.II/contrib/boost/include/boost/pending/property.hpp new file mode 100644 index 0000000000..7300c62d49 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/property.hpp @@ -0,0 +1,126 @@ +// (C) Copyright Jeremy Siek 2004 +// 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_PROPERTY_HPP +#define BOOST_PROPERTY_HPP + +#include + +namespace boost { + + struct no_property { + typedef no_property tag_type; + typedef no_property next_type; + typedef no_property value_type; + enum { num = 0 }; + typedef void kind; + }; + template + struct property : public Base { + typedef Base next_type; + typedef Tag tag_type; + typedef T value_type; + property() { } + property(const T& v) : m_value(v) { } + property(const T& v, const Base& b) : Base(b), m_value(v) { } + // copy constructor and assignment operator will be generated by compiler + T m_value; + }; + + // The BGL properties specialize property_kind and + // property_num, and use enum's for the Property type (see + // graph/properties.hpp), but the user may want to use a class + // instead with a nested kind type and num. Also, we may want to + // switch BGL back to using class types for properties at some point. + + template + struct property_kind { + typedef typename PropertyTag::kind type; + }; + + template + struct has_property { + BOOST_STATIC_CONSTANT(bool, value = true); + typedef true_type type; + }; + template <> + struct has_property { + BOOST_STATIC_CONSTANT(bool, value = false); + typedef false_type type; + }; + +} // namespace boost + +#include + +namespace boost { + + template + struct property_value { +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + typedef typename detail::build_property_tag_value_alist::type AList; + typedef typename detail::extract_value::type type; +#else + typedef typename detail::build_property_tag_value_alist::type AList; + typedef typename detail::ev_selector::type Extractor; + typedef typename Extractor::template bind_::type type; +#endif + }; + + template + inline typename property_value, Tag2>::type& + get_property_value(property& p, Tag2 tag2) { + BOOST_STATIC_CONSTANT(bool, + match = (detail::same_property::value)); + typedef property Prop; + typedef typename property_value::type T2; + T2* t2 = 0; + typedef detail::property_value_dispatch Dispatcher; + return Dispatcher::get_value(p, t2, tag2); + } + template + inline + const typename property_value, Tag2>::type& + get_property_value(const property& p, Tag2 tag2) { + BOOST_STATIC_CONSTANT(bool, + match = (detail::same_property::value)); + typedef property Prop; + typedef typename property_value::type T2; + T2* t2 = 0; + typedef detail::property_value_dispatch Dispatcher; + return Dispatcher::const_get_value(p, t2, tag2); + } + + namespace detail { +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + template + struct retag_property_list + { + typedef property type; + typedef FinalType retagged; + }; + + template + struct retag_property_list > + { + private: + typedef retag_property_list next; + + public: + typedef property type; + typedef typename next::retagged retagged; + }; + + template + struct retag_property_list + { + typedef no_property type; + typedef no_property retagged; + }; +#endif + } +} // namesapce boost + +#endif /* BOOST_PROPERTY_HPP */ diff --git a/deal.II/contrib/boost/include/boost/pending/queue.hpp b/deal.II/contrib/boost/include/boost/pending/queue.hpp new file mode 100644 index 0000000000..f5f5b6336e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/queue.hpp @@ -0,0 +1,118 @@ +// (C) Copyright Jeremy Siek 2004 +// 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_QUEUE_HPP +#define BOOST_QUEUE_HPP + +#include +#include + +namespace boost { + +template > +class queue; + +template +inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&); + +template +inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&); + + +template +class queue { + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS + template + friend bool operator== (const queue<_Tp1, _Seq1>&, + const queue<_Tp1, _Seq1>&); + template + friend bool operator< (const queue<_Tp1, _Seq1>&, + const queue<_Tp1, _Seq1>&); +#endif +public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +protected: +#endif + _Sequence c; +public: + queue() : c() {} + explicit queue(const _Sequence& __c) : c(__c) {} + + bool empty() const { return c.empty(); } + size_type size() const { return c.size(); } + reference front() { return c.front(); } + const_reference front() const { return c.front(); } + reference top() { return c.front(); } + const_reference top() const { return c.front(); } + reference back() { return c.back(); } + const_reference back() const { return c.back(); } + void push(const value_type& __x) { c.push_back(__x); } + void pop() { c.pop_front(); } + + void swap(queue& other) + { + using std::swap; + swap(c, other.c); + } +}; + +template +bool +operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) +{ + return __x.c == __y.c; +} + +template +bool +operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) +{ + return __x.c < __y.c; +} + +template +bool +operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) +{ + return !(__x == __y); +} + +template +bool +operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) +{ + return __y < __x; +} + +template +bool +operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) +{ + return !(__y < __x); +} + +template +bool +operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) +{ + return !(__x < __y); +} + +template +inline void +swap(queue<_Tp, _Sequence>& __x, queue<_Tp, _Sequence>& __y) +{ __x.swap(__y); } + +} /* namespace boost */ + +#endif /* BOOST_QUEUE_HPP */ diff --git a/deal.II/contrib/boost/include/boost/pending/relaxed_heap.hpp b/deal.II/contrib/boost/include/boost/pending/relaxed_heap.hpp new file mode 100644 index 0000000000..4b672d5beb --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/relaxed_heap.hpp @@ -0,0 +1,643 @@ +// Copyright 2004 The Trustees of Indiana University. + +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Authors: Douglas Gregor +// Andrew Lumsdaine +#ifndef BOOST_RELAXED_HEAP_HEADER +#define BOOST_RELAXED_HEAP_HEADER + +#include +#include +#include +#include + +#ifdef BOOST_RELAXED_HEAP_DEBUG +# include +#endif // BOOST_RELAXED_HEAP_DEBUG + +#if defined(BOOST_MSVC) +# pragma warning(push) +# pragma warning(disable:4355) // complaint about using 'this' to +#endif // initialize a member + +namespace boost { + +template, + typename ID = identity_property_map> +class relaxed_heap +{ + struct group; + + typedef relaxed_heap self_type; + typedef std::size_t rank_type; + +public: + typedef IndexedType value_type; + typedef rank_type size_type; + +private: + /** + * The kind of key that a group has. The actual values are discussed + * in-depth in the documentation of the @c kind field of the @c group + * structure. Note that the order of the enumerators *IS* important + * and must not be changed. + */ + enum group_key_kind { smallest_key, stored_key, largest_key }; + + struct group { + explicit group(group_key_kind kind = largest_key) + : kind(kind), parent(this), rank(0) { } + + /** The value associated with this group. This value is only valid + * when @c kind!=largest_key (which indicates a deleted + * element). Note that the use of boost::optional increases the + * memory requirements slightly but does not result in extraneous + * memory allocations or deallocations. The optional could be + * eliminated when @c value_type is a model of + * DefaultConstructible. + */ + ::boost::optional value; + + /** + * The kind of key stored at this group. This may be @c + * smallest_key, which indicates that the key is infinitely small; + * @c largest_key, which indicates that the key is infinitely + * large; or @c stored_key, which means that the key is unknown, + * but its relationship to other keys can be determined via the + * comparison function object. + */ + group_key_kind kind; + + /// The parent of this group. Will only be NULL for the dummy root group + group* parent; + + /// The rank of this group. Equivalent to the number of children in + /// the group. + rank_type rank; + + /** The children of this group. For the dummy root group, these are + * the roots. This is an array of length log n containing pointers + * to the child groups. + */ + group** children; + }; + + size_type log2(size_type n) + { + size_type leading_zeroes = 0; + do { + size_type next = n << 1; + if (n == (next >> 1)) { + ++leading_zeroes; + n = next; + } else { + break; + } + } while (true); + return sizeof(size_type) * CHAR_BIT - leading_zeroes - 1; + } + +public: + relaxed_heap(size_type n, const Compare& compare = Compare(), + const ID& id = ID()) + : compare(compare), id(id), root(smallest_key), groups(n), + smallest_value(0) + { + if (n == 0) { + root.children = new group*[1]; + return; + } + + log_n = log2(n); + + if (log_n == 0) log_n = 1; + size_type g = n / log_n; + if (n % log_n > 0) ++g; + size_type log_g = log2(g); + size_type r = log_g; + + // Reserve an appropriate amount of space for data structures, so + // that we do not need to expand them. + index_to_group.resize(g); + A.resize(r + 1, 0); + root.rank = r + 1; + root.children = new group*[(log_g + 1) * (g + 1)]; + for (rank_type i = 0; i < r+1; ++i) root.children[i] = 0; + + // Build initial heap + size_type idx = 0; + while (idx < g) { + root.children[r] = &index_to_group[idx]; + idx = build_tree(root, idx, r, log_g + 1); + if (idx != g) + r = static_cast(log2(g-idx)); + } + } + + ~relaxed_heap() { delete [] root.children; } + + void push(const value_type& x) + { + groups[get(id, x)] = x; + update(x); + } + + void update(const value_type& x) + { + group* a = &index_to_group[get(id, x) / log_n]; + if (!a->value + || *a->value == x + || compare(x, *a->value)) { + if (a != smallest_value) smallest_value = 0; + a->kind = stored_key; + a->value = x; + promote(a); + } + } + + void remove(const value_type& x) + { + group* a = &index_to_group[get(id, x) / log_n]; + assert(groups[get(id, x)] != 0); + a->value = x; + a->kind = smallest_key; + promote(a); + smallest_value = a; + pop(); + } + + value_type& top() + { + find_smallest(); + assert(smallest_value->value != 0); + return *smallest_value->value; + } + + const value_type& top() const + { + find_smallest(); + assert(smallest_value->value != 0); + return *smallest_value->value; + } + + bool empty() const + { + find_smallest(); + return !smallest_value || (smallest_value->kind == largest_key); + } + + bool contains(const value_type& x) const { return groups[get(id, x)]; } + + void pop() + { + // Fill in smallest_value. This is the group x. + find_smallest(); + group* x = smallest_value; + smallest_value = 0; + + // Make x a leaf, giving it the smallest value within its group + rank_type r = x->rank; + group* p = x->parent; + { + assert(x->value != 0); + + // Find x's group + size_type start = get(id, *x->value) - get(id, *x->value) % log_n; + size_type end = start + log_n; + if (end > groups.size()) end = groups.size(); + + // Remove the smallest value from the group, and find the new + // smallest value. + groups[get(id, *x->value)].reset(); + x->value.reset(); + x->kind = largest_key; + for (size_type i = start; i < end; ++i) { + if (groups[i] && (!x->value || compare(*groups[i], *x->value))) { + x->kind = stored_key; + x->value = groups[i]; + } + } + } + x->rank = 0; + + // Combine prior children of x with x + group* y = x; + for (size_type c = 0; c < r; ++c) { + group* child = x->children[c]; + if (A[c] == child) A[c] = 0; + y = combine(y, child); + } + + // If we got back something other than x, let y take x's place + if (y != x) { + y->parent = p; + p->children[r] = y; + + assert(r == y->rank); + if (A[y->rank] == x) + A[y->rank] = do_compare(y, p)? y : 0; + } + } + +#ifdef BOOST_RELAXED_HEAP_DEBUG + /************************************************************************* + * Debugging support * + *************************************************************************/ + void dump_tree() { dump_tree(std::cout); } + void dump_tree(std::ostream& out) { dump_tree(out, &root); } + + void dump_tree(std::ostream& out, group* p, bool in_progress = false) + { + if (!in_progress) { + out << "digraph heap {\n" + << " edge[dir=\"back\"];\n"; + } + + size_type p_index = 0; + if (p != &root) while (&index_to_group[p_index] != p) ++p_index; + + for (size_type i = 0; i < p->rank; ++i) { + group* c = p->children[i]; + if (c) { + size_type c_index = 0; + if (c != &root) while (&index_to_group[c_index] != c) ++c_index; + + out << " "; + if (p == &root) out << 'p'; else out << p_index; + out << " -> "; + if (c == &root) out << 'p'; else out << c_index; + if (A[c->rank] == c) out << " [style=\"dotted\"]"; + out << ";\n"; + dump_tree(out, c, true); + + // Emit node information + out << " "; + if (c == &root) out << 'p'; else out << c_index; + out << " [label=\""; + if (c == &root) out << 'p'; else out << c_index; + out << ":"; + size_type start = c_index * log_n; + size_type end = start + log_n; + if (end > groups.size()) end = groups.size(); + while (start != end) { + if (groups[start]) { + out << " " << get(id, *groups[start]); + if (*groups[start] == *c->value) out << "(*)"; + } + ++start; + } + out << '"'; + + if (do_compare(c, p)) { + out << " "; + if (c == &root) out << 'p'; else out << c_index; + out << ", style=\"filled\", fillcolor=\"gray\""; + } + out << "];\n"; + } else { + assert(p->parent == p); + } + } + if (!in_progress) out << "}\n"; + } + + bool valid() + { + // Check that the ranks in the A array match the ranks of the + // groups stored there. Also, the active groups must be the last + // child of their parent. + for (size_type r = 0; r < A.size(); ++r) { + if (A[r] && A[r]->rank != r) return false; + + if (A[r] && A[r]->parent->children[A[r]->parent->rank-1] != A[r]) + return false; + } + + // The root must have no value and a key of -Infinity + if (root.kind != smallest_key) return false; + + return valid(&root); + } + + bool valid(group* p) + { + for (size_type i = 0; i < p->rank; ++i) { + group* c = p->children[i]; + if (c) { + // Check link structure + if (c->parent != p) return false; + if (c->rank != i) return false; + + // A bad group must be active + if (do_compare(c, p) && A[i] != c) return false; + + // Check recursively + if (!valid(c)) return false; + } else { + // Only the root may + if (p != &root) return false; + } + } + return true; + } + +#endif // BOOST_RELAXED_HEAP_DEBUG + +private: + size_type + build_tree(group& parent, size_type idx, size_type r, size_type max_rank) + { + group& this_group = index_to_group[idx]; + this_group.parent = &parent; + ++idx; + + this_group.children = root.children + (idx * max_rank); + this_group.rank = r; + for (size_type i = 0; i < r; ++i) { + this_group.children[i] = &index_to_group[idx]; + idx = build_tree(this_group, idx, i, max_rank); + } + return idx; + } + + void find_smallest() const + { + group** roots = root.children; + + if (!smallest_value) { + std::size_t i; + for (i = 0; i < root.rank; ++i) { + if (roots[i] && + (!smallest_value || do_compare(roots[i], smallest_value))) { + smallest_value = roots[i]; + } + } + for (i = 0; i < A.size(); ++i) { + if (A[i] && (!smallest_value || do_compare(A[i], smallest_value))) + smallest_value = A[i]; + } + } + } + + bool do_compare(group* x, group* y) const + { + return (x->kind < y->kind + || (x->kind == y->kind + && x->kind == stored_key + && compare(*x->value, *y->value))); + } + + void promote(group* a) + { + assert(a != 0); + rank_type r = a->rank; + group* p = a->parent; + assert(p != 0); + if (do_compare(a, p)) { + // s is the rank + 1 sibling + group* s = p->rank > r + 1? p->children[r + 1] : 0; + + // If a is the last child of p + if (r == p->rank - 1) { + if (!A[r]) A[r] = a; + else if (A[r] != a) pair_transform(a); + } else { + assert(s != 0); + if (A[r + 1] == s) active_sibling_transform(a, s); + else good_sibling_transform(a, s); + } + } + } + + group* combine(group* a1, group* a2) + { + assert(a1->rank == a2->rank); + if (do_compare(a2, a1)) do_swap(a1, a2); + a1->children[a1->rank++] = a2; + a2->parent = a1; + clean(a1); + return a1; + } + + void clean(group* q) + { + if (2 > q->rank) return; + group* qp = q->children[q->rank-1]; + rank_type s = q->rank - 2; + group* x = q->children[s]; + group* xp = qp->children[s]; + assert(s == x->rank); + + // If x is active, swap x and xp + if (A[s] == x) { + q->children[s] = xp; + xp->parent = q; + qp->children[s] = x; + x->parent = qp; + } + } + + void pair_transform(group* a) + { +#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1 + std::cerr << "- pair transform\n"; +#endif + rank_type r = a->rank; + + // p is a's parent + group* p = a->parent; + assert(p != 0); + + // g is p's parent (a's grandparent) + group* g = p->parent; + assert(g != 0); + + // a' <- A(r) + assert(A[r] != 0); + group* ap = A[r]; + assert(ap != 0); + + // A(r) <- nil + A[r] = 0; + + // let a' have parent p' + group* pp = ap->parent; + assert(pp != 0); + + // let a' have grandparent g' + group* gp = pp->parent; + assert(gp != 0); + + // Remove a and a' from their parents + assert(ap == pp->children[pp->rank-1]); // Guaranteed because ap is active + --pp->rank; + + // Guaranteed by caller + assert(a == p->children[p->rank-1]); + --p->rank; + + // Note: a, ap, p, pp all have rank r + if (do_compare(pp, p)) { + do_swap(a, ap); + do_swap(p, pp); + do_swap(g, gp); + } + + // Assuming k(p) <= k(p') + // make p' the rank r child of p + assert(r == p->rank); + p->children[p->rank++] = pp; + pp->parent = p; + + // Combine a, ap into a rank r+1 group c + group* c = combine(a, ap); + + // make c the rank r+1 child of g' + assert(gp->rank > r+1); + gp->children[r+1] = c; + c->parent = gp; + +#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1 + std::cerr << "After pair transform...\n"; + dump_tree(); +#endif + + if (A[r+1] == pp) A[r+1] = c; + else promote(c); + } + + void active_sibling_transform(group* a, group* s) + { +#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1 + std::cerr << "- active sibling transform\n"; +#endif + group* p = a->parent; + group* g = p->parent; + + // remove a, s from their parents + assert(s->parent == p); + assert(p->children[p->rank-1] == s); + --p->rank; + assert(p->children[p->rank-1] == a); + --p->rank; + + rank_type r = a->rank; + A[r+1] = 0; + a = combine(p, a); + group* c = combine(a, s); + + // make c the rank r+2 child of g + assert(g->children[r+2] == p); + g->children[r+2] = c; + c->parent = g; + if (A[r+2] == p) A[r+2] = c; + else promote(c); + } + + void good_sibling_transform(group* a, group* s) + { +#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1 + std::cerr << "- good sibling transform\n"; +#endif + rank_type r = a->rank; + group* c = s->children[s->rank-1]; + assert(c->rank == r); + if (A[r] == c) { +#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1 + std::cerr << "- good sibling pair transform\n"; +#endif + A[r] = 0; + group* p = a->parent; + + // Remove c from its parent + --s->rank; + + // Make s the rank r child of p + s->parent = p; + p->children[r] = s; + + // combine a, c and let the result by the rank r+1 child of p + assert(p->rank > r+1); + group* x = combine(a, c); + x->parent = p; + p->children[r+1] = x; + + if (A[r+1] == s) A[r+1] = x; + else promote(x); + +#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1 + dump_tree(std::cerr); +#endif + // pair_transform(a); + } else { + // Clean operation + group* p = a->parent; + s->children[r] = a; + a->parent = s; + p->children[r] = c; + c->parent = p; + + promote(a); + } + } + + static void do_swap(group*& x, group*& y) + { + group* tmp = x; + x = y; + y = tmp; + } + + /// Function object that compares two values in the heap + Compare compare; + + /// Mapping from values to indices in the range [0, n). + ID id; + + /** The root group of the queue. This group is special because it will + * never store a value, but it acts as a parent to all of the + * roots. Thus, its list of children is the list of roots. + */ + group root; + + /** Mapping from the group index of a value to the group associated + * with that value. If a value is not in the queue, then the "value" + * field will be empty. + */ + std::vector index_to_group; + + /** Flat data structure containing the values in each of the + * groups. It will be indexed via the id of the values. The groups + * are each log_n long, with the last group potentially being + * smaller. + */ + std::vector< ::boost::optional > groups; + + /** The list of active groups, indexed by rank. When A[r] is null, + * there is no active group of rank r. Otherwise, A[r] is the active + * group of rank r. + */ + std::vector A; + + /** The group containing the smallest value in the queue, which must + * be either a root or an active group. If this group is null, then we + * will need to search for this group when it is needed. + */ + mutable group* smallest_value; + + /// Cached value log2(n) + size_type log_n; +}; + + +} // end namespace boost + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +#endif // BOOST_RELAXED_HEAP_HEADER diff --git a/deal.II/contrib/boost/include/boost/pending/stringtok.hpp b/deal.II/contrib/boost/include/boost/pending/stringtok.hpp new file mode 100644 index 0000000000..ae52e8db1d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/pending/stringtok.hpp @@ -0,0 +1,111 @@ +// (C) Copyright Jeremy Siek 2004 +// 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) + +/* + * stringtok.hpp -- Breaks a string into tokens. This is an example for lib3. + * + * Template function looks like this: + * + * template + * void stringtok (Container &l, + * string const &s, + * char const * const ws = " \t\n"); + * + * A nondestructive version of strtok() that handles its own memory and can + * be broken up by any character(s). Does all the work at once rather than + * in an invocation loop like strtok() requires. + * + * Container is any type that supports push_back(a_string), although using + * list and deque are indicated due to their O(1) push_back. + * (I prefer deque<> because op[]/at() is available as well.) The first + * parameter references an existing Container. + * + * s is the string to be tokenized. From the parameter declaration, it can + * be seen that s is not affected. Since references-to-const may refer to + * temporaries, you could use stringtok(some_container, readline("")) when + * using the GNU readline library. + * + * The final parameter is an array of characters that serve as whitespace. + * Whitespace characters default to one or more of tab, space, and newline, + * in any combination. + * + * 'l' need not be empty on entry. On return, 'l' will have the token + * strings appended. + * + * + * [Example: + * list ls; + * stringtok (ls, " this \t is\t\n a test "); + * for (list::const_iterator i = ls.begin(); + * i != ls.end(); ++i) + * { + * cerr << ':' << (*i) << ":\n"; + * } + * + * would print + * :this: + * :is: + * :a: + * :test: + * -end example] + * + * pedwards@jaj.com May 1999 +*/ + + +#include +#include // for strchr + + +/***************************************************************** + * This is the only part of the implementation that I don't like. + * It can probably be improved upon by the reader... +*/ +namespace { + inline bool + isws (char c, char const * const wstr) + { + using namespace std; + return (strchr(wstr,c) != NULL); + } +} + +namespace boost { + +/***************************************************************** + * Simplistic and quite Standard, but a bit slow. This should be + * templatized on basic_string instead, or on a more generic StringT + * that just happens to support ::size_type, .substr(), and so on. + * I had hoped that "whitespace" would be a trait, but it isn't, so + * the user must supply it. Enh, this lets them break up strings on + * different things easier than traits would anyhow. +*/ +template +void +stringtok (Container &l, std::string const &s, char const * const ws = " \t\n") +{ + typedef std::string::size_type size_type; + const size_type S = s.size(); + size_type i = 0; + + while (i < S) { + // eat leading whitespace + while ((i < S) && (isws(s[i],ws))) ++i; + if (i == S) return; // nothing left but WS + + // find end of word + size_type j = i+1; + while ((j < S) && (!isws(s[j],ws))) ++j; + + // add word + l.push_back(s.substr(i,j-i)); + + // set up for next loop + i = j+1; + } +} + + +} // namespace boost diff --git a/deal.II/contrib/boost/include/boost/preprocessor/stringize.hpp b/deal.II/contrib/boost/include/boost/preprocessor/stringize.hpp new file mode 100644 index 0000000000..01f283e852 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/stringize.hpp @@ -0,0 +1,34 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_STRINGIZE_HPP +# define BOOST_PREPROCESSOR_STRINGIZE_HPP +# +# include +# +# /* BOOST_PP_STRINGIZE */ +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_A((text)) +# define BOOST_PP_STRINGIZE_A(arg) BOOST_PP_STRINGIZE_B ## (arg) +# define BOOST_PP_STRINGIZE_B(arg) BOOST_PP_STRINGIZE_I ## arg +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_OO((text)) +# define BOOST_PP_STRINGIZE_OO(par) BOOST_PP_STRINGIZE_I ## par +# else +# define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_I(text) +# endif +# +# define BOOST_PP_STRINGIZE_I(text) #text +# +# endif diff --git a/deal.II/contrib/boost/include/boost/type_traits/conversion_traits.hpp b/deal.II/contrib/boost/include/boost/type_traits/conversion_traits.hpp new file mode 100644 index 0000000000..82785315ec --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/conversion_traits.hpp @@ -0,0 +1,17 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) +// Copyright 1999, 2000 Jaakko J„rvi (jaakko.jarvi@cs.utu.fi) +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED +#define BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED + +#include "boost/type_traits/is_convertible.hpp" + +#endif // BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/same_traits.hpp b/deal.II/contrib/boost/include/boost/type_traits/same_traits.hpp new file mode 100644 index 0000000000..899193cbd7 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/same_traits.hpp @@ -0,0 +1,15 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// defines is_same: + +#ifndef BOOST_TT_SAME_TRAITS_HPP_INCLUDED +#define BOOST_TT_SAME_TRAITS_HPP_INCLUDED + +#include "boost/type_traits/is_same.hpp" + +#endif // BOOST_TT_SAME_TRAITS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/utility/compare_pointees.hpp b/deal.II/contrib/boost/include/boost/utility/compare_pointees.hpp new file mode 100644 index 0000000000..e6888a6efa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/utility/compare_pointees.hpp @@ -0,0 +1,68 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/lib/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP +#define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP + +#include + +namespace boost { + +// template bool equal_pointees(OP const& x, OP const& y); +// template struct equal_pointees_t; +// +// Being OP a model of OptionalPointee (either a pointer or an optional): +// +// If both x and y have valid pointees, returns the result of (*x == *y) +// If only one has a valid pointee, returns false. +// If none have valid pointees, returns true. +// No-throw +template +inline +bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y ) +{ + return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ; +} + +template +struct equal_pointees_t : std::binary_function +{ + bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const + { return equal_pointees(x,y) ; } +} ; + +// template bool less_pointees(OP const& x, OP const& y); +// template struct less_pointees_t; +// +// Being OP a model of OptionalPointee (either a pointer or an optional): +// +// If y has not a valid pointee, returns false. +// ElseIf x has not a valid pointee, returns true. +// ElseIf both x and y have valid pointees, returns the result of (*x < *y) +// No-throw +template +inline +bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y ) +{ + return !y ? false : ( !x ? true : (*x) < (*y) ) ; +} + +template +struct less_pointees_t : std::binary_function +{ + bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const + { return less_pointees(x,y) ; } +} ; + +} // namespace boost + +#endif +