From noreply at r-forge.r-project.org Sat May 4 02:11:16 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 02:11:16 +0200 (CEST) Subject: [Boostheaders-commits] r29 - / Message-ID: <20130504001116.9206B184F7C@r-forge.r-project.org> Author: edd Date: 2013-05-04 02:11:16 +0200 (Sat, 04 May 2013) New Revision: 29 Added: CreateBoost.sh Log: shell-script variant of CreateBoost.R extended to try to deal with issue tickets #2527 (foreach), #2533 (math/dist.) and #2768 (iostream) appears to work fine, though iostream is 'empty' Added: CreateBoost.sh =================================================================== --- CreateBoost.sh (rev 0) +++ CreateBoost.sh 2013-05-04 00:11:16 UTC (rev 29) @@ -0,0 +1,119 @@ +#!/bin/sh +## +## CreateBoost.sh -- derived from CreateBoost.R +## +## Jay Emerson and Dirk Eddelbuettel, 2012 - 2013 + +## First, download the new version of the Boost Libraries and +## set the variables boostall and version, here: +boostall="boost_1_51_0.tar.gz" +version="1.51.0-1" +date="2013-05-02" +pkgdir="pkg/BoostHeaders" +## September 2, 2012 + +## Additional resources we require and need to test for +## 'sources' lists the directories we scan for Boost components +sources="../bigmemory" +## 'progs' lists the programs we need +progs="bcp" + + +## Derive the 'bootroot' name from the tarball, using basename(1) +boostroot=$(basename ${boostall} ".tar.gz") + +## DEBUG display +echo "Check: ${boostall} ${version} ${date} ${pkgdir} ${boostroot}" + +## A sanity check here before continuing: +if [ ! -f ${boostall} ] && [ ! -d ${boostroot} ]; then + echo "The Boost input file or directory do not exist. Exiting." + exit -1 +fi + +## DE: Needed? Can we not just overwrite? +#if [ -d ${pkgdir} ]; then +# echo "svn rmdir pkg/BoostHeaders" +# echo "Then when this is done and tested, add it back into the svn" +# echo "stop 'Move aside the old BoostHeaders'" +#fi + +## Another sanity check +for prog in ${progs}; do + if [ ! -x /usr/bin/${prog} ] && [ ! -x /usr/local/bin/${prog} ]; then + echo "** Program '${prog}' not found, exiting" + exit -1 + fi +done + +## Check for sources +for dir in ${sources}; do + if [ ! -d ${dir} ]; then + echo "** Source directory ${dir} not found, exiting" + exit -1 + fi +done + +######################################################################## +# Unpack, copy from boost to BoostHeaders/inst/include, +# and build the supporting infrastructure of the package. + +if [ ! -d ${boostroot} ]; then + tar -zxf ${boostall} +fi + +mkdir -p ${pkgdir} \ + ${pkgdir}/inst \ + ${pkgdir}/man \ + ${pkgdir}/inst/include + +# bcp --scan --boost=boost_1_51_0 ../bigmemory/pkg/bigmemory/src/*.cpp test + +# The bigmemory Boost dependencies: +bcp --scan --boost=${boostroot} ../bigmemory/pkg/bigmemory/src/*.cpp \ + ${pkgdir}/inst/include > bcp.log + +# Plus filesystem +bcp --boost=${boostroot} filesystem ${pkgdir}/inst/include >> bcp.log + +# Plus foreach (cf issue ticket #2527) +bcp --boost=${boostroot} foreach ${pkgdir}/inst/include >> bcp.log + +# Plus math/distributions (cf issue ticket #2533) +bcp --boost=${boostroot} math/distributions ${pkgdir}/inst/include >> bcp.log + +# Plus iostream (cf issue ticket #2768) -- thia is a null-op, why? +bcp --boost=${boostroot} iostream ${pkgdir}/inst/include >> bcp.log + +# TODO: check with other packages + + +## Some post processing +rm -r ${pkgdir}/inst/include/libs \ + ${pkgdir}/inst/include/Jamroot \ + ${pkgdir}/inst/include/boost.png \ + ${pkgdir}/inst/include/doc + +cp BoostHeadersROOT/LICENSE* \ + BoostHeadersROOT/NAMESPACE ${pkgdir} +cp -p BoostHeadersROOT/man/*.Rd ${pkgdir}/man + +sed -e "s/XXX/${version}/g" \ + -e "s/YYY/${date}/g" \ + BoostHeadersROOT/DESCRIPTION > ${pkgdir}/DESCRIPTION +sed -e "s/XXX/${version}/g" -e "s/YYY/${date}/g" \ + BoostHeadersROOT/man/BoostHeaders-package.Rd > + ${pkgdir}/man/BoostHeaders-package.Rd + + +######################################################################## +# Now fix up things that don't work. Here, we need to stay +# organized and decide who is the maintainer of what, but this script +# is the master record of any changes made to the boost tree. + +## bigmemory et.al. will require changes to support Windows; we +## believe the Mac and Linux versions will be fine without changes. + +## We'll invite co-maintainers who identify changes needed to support +## their specific libraries. + Property changes on: CreateBoost.sh ___________________________________________________________________ Added: svn:executable + * From noreply at r-forge.r-project.org Sat May 4 02:19:29 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 02:19:29 +0200 (CEST) Subject: [Boostheaders-commits] r30 - / Message-ID: <20130504001929.CC743184C14@r-forge.r-project.org> Author: edd Date: 2013-05-04 02:19:29 +0200 (Sat, 04 May 2013) New Revision: 30 Modified: CreateBoost.R CreateBoost.sh Log: minor fixes/edits in CreateBoost.sh added comment to CreateBoost.R pointing to CreateBoost.sh Modified: CreateBoost.R =================================================================== --- CreateBoost.R 2013-05-04 00:11:16 UTC (rev 29) +++ CreateBoost.R 2013-05-04 00:19:29 UTC (rev 30) @@ -1,6 +1,9 @@ ## Jay Emerson ## September 2, 2012 +## TODO(DE): Are we sure this isn't more easily written as a shell script? +## (DE): Please see CreateBoost.sh which has extensions as well + ## First, download the new version of the Boost Libraries and ## set the variables boostall and version, here: boostall <- 'boost_1_51_0.tar.gz' Modified: CreateBoost.sh =================================================================== --- CreateBoost.sh 2013-05-04 00:11:16 UTC (rev 29) +++ CreateBoost.sh 2013-05-04 00:19:29 UTC (rev 30) @@ -10,8 +10,8 @@ version="1.51.0-1" date="2013-05-02" pkgdir="pkg/BoostHeaders" -## September 2, 2012 + ## Additional resources we require and need to test for ## 'sources' lists the directories we scan for Boost components sources="../bigmemory" @@ -102,8 +102,7 @@ -e "s/YYY/${date}/g" \ BoostHeadersROOT/DESCRIPTION > ${pkgdir}/DESCRIPTION sed -e "s/XXX/${version}/g" -e "s/YYY/${date}/g" \ - BoostHeadersROOT/man/BoostHeaders-package.Rd > - ${pkgdir}/man/BoostHeaders-package.Rd + BoostHeadersROOT/man/BoostHeaders-package.Rd > ${pkgdir}/man/BoostHeaders-package.Rd ######################################################################## From noreply at r-forge.r-project.org Sat May 4 02:30:18 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 02:30:18 +0200 (CEST) Subject: [Boostheaders-commits] r31 - / Message-ID: <20130504003018.5B77F184C14@r-forge.r-project.org> Author: edd Date: 2013-05-04 02:30:17 +0200 (Sat, 04 May 2013) New Revision: 31 Modified: CreateBoost.sh ToCRAN.txt Log: minor edit in ToCRAN catching up on CreateBoost.sh to be current with CreateBoost.R (my bad) Modified: CreateBoost.sh =================================================================== --- CreateBoost.sh 2013-05-04 00:19:29 UTC (rev 30) +++ CreateBoost.sh 2013-05-04 00:30:17 UTC (rev 31) @@ -9,7 +9,7 @@ boostall="boost_1_51_0.tar.gz" version="1.51.0-1" date="2013-05-02" -pkgdir="pkg/BoostHeaders" +pkgdir="pkg/BH" ## Additional resources we require and need to test for @@ -33,9 +33,10 @@ ## DE: Needed? Can we not just overwrite? #if [ -d ${pkgdir} ]; then -# echo "svn rmdir pkg/BoostHeaders" +# echo "svn rm pkg/BH" +# echo "svn commit -m'removal'" # echo "Then when this is done and tested, add it back into the svn" -# echo "stop 'Move aside the old BoostHeaders'" +# echo "stop 'Move aside the old BH'" #fi ## Another sanity check @@ -72,6 +73,9 @@ # The bigmemory Boost dependencies: bcp --scan --boost=${boostroot} ../bigmemory/pkg/bigmemory/src/*.cpp \ ${pkgdir}/inst/include > bcp.log +# The synchronicity Boost dependencies: +bcp --scan --boost=${boostroot} ../bigmemory/pkg/synchronicity/src/*.cpp \ + ${pkgdir}/inst/include > bcp.log # Plus filesystem bcp --boost=${boostroot} filesystem ${pkgdir}/inst/include >> bcp.log @@ -89,10 +93,10 @@ ## Some post processing -rm -r ${pkgdir}/inst/include/libs \ - ${pkgdir}/inst/include/Jamroot \ - ${pkgdir}/inst/include/boost.png \ - ${pkgdir}/inst/include/doc +rm -rf ${pkgdir}/inst/include/libs \ + ${pkgdir}/inst/include/Jamroot \ + ${pkgdir}/inst/include/boost.png \ + ${pkgdir}/inst/include/doc cp BoostHeadersROOT/LICENSE* \ BoostHeadersROOT/NAMESPACE ${pkgdir} @@ -102,11 +106,12 @@ -e "s/YYY/${date}/g" \ BoostHeadersROOT/DESCRIPTION > ${pkgdir}/DESCRIPTION sed -e "s/XXX/${version}/g" -e "s/YYY/${date}/g" \ - BoostHeadersROOT/man/BoostHeaders-package.Rd > ${pkgdir}/man/BoostHeaders-package.Rd + BoostHeadersROOT/man/BH-package.Rd > ${pkgdir}/man/BH-package.Rd +# echo "Now 'svn add pkg/BH' and 'svn commit' -######################################################################## -# Now fix up things that don't work. Here, we need to stay +######################################################################### +# Now fix up things that don't work, if necessary. Here, we need to stay # organized and decide who is the maintainer of what, but this script # is the master record of any changes made to the boost tree. Modified: ToCRAN.txt =================================================================== --- ToCRAN.txt 2013-05-04 00:19:29 UTC (rev 30) +++ ToCRAN.txt 2013-05-04 00:30:17 UTC (rev 31) @@ -1,4 +1,4 @@ -CRAN submission BoostHeaders 1.15.0-0 +CRAN submission BoostHeaders 1.51.0-0 We have read and agreed to the CRAN policies. We note that the package is larger than usually recommended, and explain From noreply at r-forge.r-project.org Sat May 4 02:55:43 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 02:55:43 +0200 (CEST) Subject: [Boostheaders-commits] r32 - in pkg/BH/inst/include/boost: . detail math math/policies math/special_functions math/special_functions/detail math/tools mpl preprocessor/comparison test tuple utility utility/detail Message-ID: <20130504005543.5FA901854D5@r-forge.r-project.org> Author: edd Date: 2013-05-04 02:55:42 +0200 (Sat, 04 May 2013) New Revision: 32 Added: pkg/BH/inst/include/boost/blank.hpp pkg/BH/inst/include/boost/blank_fwd.hpp pkg/BH/inst/include/boost/detail/templated_streams.hpp pkg/BH/inst/include/boost/foreach.hpp pkg/BH/inst/include/boost/foreach_fwd.hpp pkg/BH/inst/include/boost/format.hpp pkg/BH/inst/include/boost/format/ pkg/BH/inst/include/boost/fusion/ pkg/BH/inst/include/boost/math/constants/ pkg/BH/inst/include/boost/math/distributions.hpp pkg/BH/inst/include/boost/math/distributions/ pkg/BH/inst/include/boost/math/policies/error_handling.hpp pkg/BH/inst/include/boost/math/special_functions/bessel.hpp pkg/BH/inst/include/boost/math/special_functions/beta.hpp pkg/BH/inst/include/boost/math/special_functions/cbrt.hpp pkg/BH/inst/include/boost/math/special_functions/cos_pi.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_i0.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_i1.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_ik.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_j0.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_j1.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_jn.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_jy.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_jy_asym.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_jy_series.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_k0.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_k1.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_kn.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_y0.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_y1.hpp pkg/BH/inst/include/boost/math/special_functions/detail/bessel_yn.hpp pkg/BH/inst/include/boost/math/special_functions/detail/erf_inv.hpp pkg/BH/inst/include/boost/math/special_functions/detail/gamma_inva.hpp pkg/BH/inst/include/boost/math/special_functions/detail/ibeta_inv_ab.hpp pkg/BH/inst/include/boost/math/special_functions/detail/ibeta_inverse.hpp pkg/BH/inst/include/boost/math/special_functions/detail/iconv.hpp pkg/BH/inst/include/boost/math/special_functions/detail/igamma_inverse.hpp pkg/BH/inst/include/boost/math/special_functions/detail/igamma_large.hpp pkg/BH/inst/include/boost/math/special_functions/detail/lanczos_sse2.hpp pkg/BH/inst/include/boost/math/special_functions/detail/lgamma_small.hpp pkg/BH/inst/include/boost/math/special_functions/detail/t_distribution_inv.hpp pkg/BH/inst/include/boost/math/special_functions/detail/unchecked_factorial.hpp pkg/BH/inst/include/boost/math/special_functions/erf.hpp pkg/BH/inst/include/boost/math/special_functions/expm1.hpp pkg/BH/inst/include/boost/math/special_functions/factorials.hpp pkg/BH/inst/include/boost/math/special_functions/gamma.hpp pkg/BH/inst/include/boost/math/special_functions/hypot.hpp pkg/BH/inst/include/boost/math/special_functions/lanczos.hpp pkg/BH/inst/include/boost/math/special_functions/log1p.hpp pkg/BH/inst/include/boost/math/special_functions/owens_t.hpp pkg/BH/inst/include/boost/math/special_functions/pow.hpp pkg/BH/inst/include/boost/math/special_functions/powm1.hpp pkg/BH/inst/include/boost/math/special_functions/prime.hpp pkg/BH/inst/include/boost/math/special_functions/round.hpp pkg/BH/inst/include/boost/math/special_functions/sin_pi.hpp pkg/BH/inst/include/boost/math/special_functions/sinc.hpp pkg/BH/inst/include/boost/math/special_functions/sqrt1pm1.hpp pkg/BH/inst/include/boost/math/special_functions/trunc.hpp pkg/BH/inst/include/boost/math/tools/big_constant.hpp pkg/BH/inst/include/boost/math/tools/detail/ pkg/BH/inst/include/boost/math/tools/fraction.hpp pkg/BH/inst/include/boost/math/tools/minima.hpp pkg/BH/inst/include/boost/math/tools/precision.hpp pkg/BH/inst/include/boost/math/tools/rational.hpp pkg/BH/inst/include/boost/math/tools/roots.hpp pkg/BH/inst/include/boost/math/tools/series.hpp pkg/BH/inst/include/boost/math/tools/toms748_solve.hpp pkg/BH/inst/include/boost/math/tools/traits.hpp pkg/BH/inst/include/boost/math/tools/tuple.hpp pkg/BH/inst/include/boost/mpl/begin.hpp pkg/BH/inst/include/boost/mpl/divides.hpp pkg/BH/inst/include/boost/mpl/empty_base.hpp pkg/BH/inst/include/boost/mpl/end.hpp pkg/BH/inst/include/boost/mpl/inherit.hpp pkg/BH/inst/include/boost/preprocessor/comparison/less.hpp pkg/BH/inst/include/boost/preprocessor/comparison/not_equal.hpp pkg/BH/inst/include/boost/test/minimal.hpp pkg/BH/inst/include/boost/tr1/ pkg/BH/inst/include/boost/tuple/tuple_comparison.hpp pkg/BH/inst/include/boost/utility/detail/result_of_iterate.hpp pkg/BH/inst/include/boost/utility/result_of.hpp Log: steps towards BH 1.51.0-1 with foreach and math distributions Added: pkg/BH/inst/include/boost/blank.hpp =================================================================== --- pkg/BH/inst/include/boost/blank.hpp (rev 0) +++ pkg/BH/inst/include/boost/blank.hpp 2013-05-04 00:55:42 UTC (rev 32) @@ -0,0 +1,106 @@ +//----------------------------------------------------------------------------- +// boost blank.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_BLANK_HPP +#define BOOST_BLANK_HPP + +#include "boost/blank_fwd.hpp" + +#if !defined(BOOST_NO_IOSTREAM) +#include // for std::basic_ostream forward declare +#include "boost/detail/templated_streams.hpp" +#endif // BOOST_NO_IOSTREAM + +#include "boost/mpl/bool.hpp" +#include "boost/type_traits/is_empty.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/type_traits/is_stateless.hpp" + +namespace boost { + +struct blank +{ +}; + +// type traits specializations +// + +template <> +struct is_pod< blank > + : mpl::true_ +{ +}; + +template <> +struct is_empty< blank > + : mpl::true_ +{ +}; + +template <> +struct is_stateless< blank > + : mpl::true_ +{ +}; + +// relational operators +// + +inline bool operator==(const blank&, const blank&) +{ + return true; +} + +inline bool operator<=(const blank&, const blank&) +{ + return true; +} + +inline bool operator>=(const blank&, const blank&) +{ + return true; +} + +inline bool operator!=(const blank&, const blank&) +{ + return false; +} + +inline bool operator<(const blank&, const blank&) +{ + return false; +} + +inline bool operator>(const blank&, const blank&) +{ + return false; +} + +// streaming support +// +#if !defined(BOOST_NO_IOSTREAM) + +BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) +inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<( + BOOST_TEMPLATED_STREAM(ostream, E,T)& out + , const blank& + ) +{ + // (output nothing) + return out; +} + +#endif // BOOST_NO_IOSTREAM + +} // namespace boost + +#endif // BOOST_BLANK_HPP Added: pkg/BH/inst/include/boost/blank_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/blank_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/blank_fwd.hpp 2013-05-04 00:55:42 UTC (rev 32) @@ -0,0 +1,22 @@ +//----------------------------------------------------------------------------- +// boost blank_fwd.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_BLANK_FWD_HPP +#define BOOST_BLANK_FWD_HPP + +namespace boost { + +struct blank; + +} // namespace boost + +#endif // BOOST_BLANK_FWD_HPP Added: pkg/BH/inst/include/boost/detail/templated_streams.hpp =================================================================== --- pkg/BH/inst/include/boost/detail/templated_streams.hpp (rev 0) +++ pkg/BH/inst/include/boost/detail/templated_streams.hpp 2013-05-04 00:55:42 UTC (rev 32) @@ -0,0 +1,74 @@ +//----------------------------------------------------------------------------- +// boost detail/templated_streams.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_TEMPLATED_STREAMS_HPP +#define BOOST_DETAIL_TEMPLATED_STREAMS_HPP + +#include "boost/config.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// (detail) BOOST_TEMPLATED_STREAM_* macros +// +// Provides workaround platforms without stream class templates. +// + +#if !defined(BOOST_NO_STD_LOCALE) + +#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) \ + template < typename E , typename T > + +#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) \ + template < typename E , typename T , typename A > + +#define BOOST_TEMPLATED_STREAM_ARGS(E,T) \ + typename E , typename T + +#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) \ + typename E , typename T , typename A + +#define BOOST_TEMPLATED_STREAM_COMMA , + +#define BOOST_TEMPLATED_STREAM_ELEM(E) E +#define BOOST_TEMPLATED_STREAM_TRAITS(T) T +#define BOOST_TEMPLATED_STREAM_ALLOC(A) A + +#define BOOST_TEMPLATED_STREAM(X,E,T) \ + BOOST_JOIN(std::basic_,X)< E , T > + +#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ + BOOST_JOIN(std::basic_,X)< E , T , A > + +#else // defined(BOOST_NO_STD_LOCALE) + +#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) /**/ + +#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) /**/ + +#define BOOST_TEMPLATED_STREAM_ARGS(E,T) /**/ + +#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) /**/ + +#define BOOST_TEMPLATED_STREAM_COMMA /**/ + +#define BOOST_TEMPLATED_STREAM_ELEM(E) char +#define BOOST_TEMPLATED_STREAM_TRAITS(T) std::char_traits +#define BOOST_TEMPLATED_STREAM_ALLOC(A) std::allocator + +#define BOOST_TEMPLATED_STREAM(X,E,T) \ + std::X + +#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ + std::X + +#endif // BOOST_NO_STD_LOCALE + +#endif // BOOST_DETAIL_TEMPLATED_STREAMS_HPP Added: pkg/BH/inst/include/boost/foreach.hpp =================================================================== --- pkg/BH/inst/include/boost/foreach.hpp (rev 0) +++ pkg/BH/inst/include/boost/foreach.hpp 2013-05-04 00:55:42 UTC (rev 32) @@ -0,0 +1,1124 @@ +/////////////////////////////////////////////////////////////////////////////// +// foreach.hpp header file +// +// Copyright 2004 Eric Niebler. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// See http://www.boost.org/libs/foreach for documentation +// +// Credits: +// Anson Tsao - for the initial inspiration and several good suggestions. +// Thorsten Ottosen - for Boost.Range, and for suggesting a way to detect +// const-qualified rvalues at compile time on VC7.1+ +// Russell Hind - For help porting to Borland +// Alisdair Meredith - For help porting to Borland +// Stefan Slapeta - For help porting to Intel +// David Jenkins - For help finding a Microsoft Code Analysis bug +// mimomorin at ... - For a patch to use rvalue refs on supporting compilers + +#ifndef BOOST_FOREACH + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include +#include // for std::pair + +#include +#include + +// Some compilers let us detect even const-qualified rvalues at compile-time +#if !defined(BOOST_NO_RVALUE_REFERENCES) \ + || BOOST_WORKAROUND(BOOST_MSVC, >= 1310) && !defined(_PREFAST_) \ + || (BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 5) && !defined(BOOST_INTEL) && \ + !defined(BOOST_CLANG)) \ + || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL) && \ + !defined(BOOST_CLANG)) +# define BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION +#else +// Some compilers allow temporaries to be bound to non-const references. +// These compilers make it impossible to for BOOST_FOREACH to detect +// temporaries and avoid reevaluation of the collection expression. +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__BORLANDC__, < 0x593) \ + || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) \ + || BOOST_WORKAROUND(__DECCXX_VER, <= 60590042) +# define BOOST_FOREACH_NO_RVALUE_DETECTION +# endif +// Some compilers do not correctly implement the lvalue/rvalue conversion +// rules of the ternary conditional operator. +# if defined(BOOST_FOREACH_NO_RVALUE_DETECTION) \ + || defined(BOOST_NO_SFINAE) \ + || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(__GNUC__, < 3) \ + || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 2)) \ + || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__)) \ + || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \ + || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, >= 0x5100) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x590)) +# define BOOST_FOREACH_NO_CONST_RVALUE_DETECTION +# else +# define BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +# endif +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +# include +# include +# include +# include +#endif + +namespace boost +{ + +// forward declarations for iterator_range +template +class iterator_range; + +// forward declarations for sub_range +template +class sub_range; + +namespace foreach +{ + /////////////////////////////////////////////////////////////////////////////// + // in_range + // + template + inline std::pair in_range(T begin, T end) + { + return std::make_pair(begin, end); + } + + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::is_lightweight_proxy + // Specialize this for user-defined collection types if they are inexpensive to copy. + // This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff. + template + struct is_lightweight_proxy + : boost::mpl::false_ + { + }; + + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::is_noncopyable + // Specialize this for user-defined collection types if they cannot be copied. + // This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff. + template + struct is_noncopyable + #if !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) && !defined(BOOST_NO_IS_ABSTRACT) + : boost::mpl::or_< + boost::is_abstract + , boost::is_base_and_derived + > + #elif !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) + : boost::is_base_and_derived + #elif !defined(BOOST_NO_IS_ABSTRACT) + : boost::is_abstract + #else + : boost::mpl::false_ + #endif + { + }; + +} // namespace foreach + +} // namespace boost + +// vc6/7 needs help ordering the following overloads +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +# define BOOST_FOREACH_TAG_DEFAULT ... +#else +# define BOOST_FOREACH_TAG_DEFAULT boost::foreach::tag +#endif + +/////////////////////////////////////////////////////////////////////////////// +// boost_foreach_is_lightweight_proxy +// Another customization point for the is_lightweight_proxy optimization, +// this one works on legacy compilers. Overload boost_foreach_is_lightweight_proxy +// at the global namespace for your type. +template +inline boost::foreach::is_lightweight_proxy * +boost_foreach_is_lightweight_proxy(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(std::pair *&, boost::foreach::tag) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(boost::iterator_range *&, boost::foreach::tag) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(boost::sub_range *&, boost::foreach::tag) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; } + +/////////////////////////////////////////////////////////////////////////////// +// boost_foreach_is_noncopyable +// Another customization point for the is_noncopyable trait, +// this one works on legacy compilers. Overload boost_foreach_is_noncopyable +// at the global namespace for your type. +template +inline boost::foreach::is_noncopyable * +boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; } + +namespace boost +{ + +namespace foreach_detail_ +{ + +/////////////////////////////////////////////////////////////////////////////// +// Define some utilities for assessing the properties of expressions +// +template +inline boost::mpl::and_ *and_(Bool1 *, Bool2 *) { return 0; } + +template +inline boost::mpl::and_ *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; } + +template +inline boost::mpl::or_ *or_(Bool1 *, Bool2 *) { return 0; } + +template +inline boost::mpl::or_ *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; } + +template +inline boost::mpl::not_ *not_(Bool1 *) { return 0; } + +template +inline boost::is_array *is_array_(T const &) { return 0; } + +template +inline boost::is_const *is_const_(T &) { return 0; } + +#ifndef BOOST_FOREACH_NO_RVALUE_DETECTION +template +inline boost::mpl::true_ *is_const_(T const &) { return 0; } +#endif + +#ifdef BOOST_NO_RVALUE_REFERENCES +template +inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; } + +template +inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; } +#else +template +inline boost::is_rvalue_reference *is_rvalue_(T &&, int) { return 0; } +#endif + +/////////////////////////////////////////////////////////////////////////////// +// auto_any_t/auto_any +// General utility for putting an object of any type into automatic storage +struct auto_any_base +{ + // auto_any_base must evaluate to false in boolean context so that + // they can be declared in if() statements. + operator bool() const + { + return false; + } +}; + +template +struct auto_any : auto_any_base +{ + explicit auto_any(T const &t) + : item(t) + { + } + + // temporaries of type auto_any will be bound to const auto_any_base + // references, but we still want to be able to mutate the stored + // data, so declare it as mutable. + mutable T item; +}; + +typedef auto_any_base const &auto_any_t; + +template +inline BOOST_DEDUCED_TYPENAME boost::mpl::if_::type &auto_any_cast(auto_any_t a) +{ + return static_cast const &>(a).item; +} + +typedef boost::mpl::true_ const_; + +/////////////////////////////////////////////////////////////////////////////// +// type2type +// +template +struct type2type + : boost::mpl::if_ +{ +}; + +template +struct wrap_cstr +{ + typedef T type; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef char *iterator; + typedef char *const_iterator; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef char const *iterator; + typedef char const *const_iterator; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef wchar_t *iterator; + typedef wchar_t *const_iterator; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef wchar_t const *iterator; + typedef wchar_t const *const_iterator; +}; + +template +struct is_char_array + : mpl::and_< + is_array + , mpl::or_< + is_convertible + , is_convertible + > + > +{}; + +template +struct foreach_iterator +{ + // **** READ THIS IF YOUR COMPILE BREAKS HERE **** + // + // There is an ambiguity about how to iterate over arrays of char and wchar_t. + // Should the last array element be treated as a null terminator to be skipped, or + // is it just like any other element in the array? To fix the problem, you must + // say which behavior you want. + // + // To treat the container as a null-terminated string, merely cast it to a + // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ... + // + // To treat the container as an array, use boost::as_array() in , + // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... + #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 + BOOST_MPL_ASSERT_MSG( (!is_char_array::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); + #endif + + // If the type is a pointer to a null terminated string (as opposed + // to an array type), there is no ambiguity. + typedef BOOST_DEDUCED_TYPENAME wrap_cstr::type container; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< + C + , range_const_iterator + , range_mutable_iterator + >::type type; +}; + + +template +struct foreach_reverse_iterator +{ + // **** READ THIS IF YOUR COMPILE BREAKS HERE **** + // + // There is an ambiguity about how to iterate over arrays of char and wchar_t. + // Should the last array element be treated as a null terminator to be skipped, or + // is it just like any other element in the array? To fix the problem, you must + // say which behavior you want. + // + // To treat the container as a null-terminated string, merely cast it to a + // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ... + // + // To treat the container as an array, use boost::as_array() in , + // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... + #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 + BOOST_MPL_ASSERT_MSG( (!is_char_array::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); + #endif + + // If the type is a pointer to a null terminated string (as opposed + // to an array type), there is no ambiguity. + typedef BOOST_DEDUCED_TYPENAME wrap_cstr::type container; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< + C + , range_reverse_iterator + , range_reverse_iterator + >::type type; +}; + +template +struct foreach_reference + : iterator_reference::type> +{ +}; + +/////////////////////////////////////////////////////////////////////////////// +// encode_type +// +template +inline type2type *encode_type(T &, boost::mpl::false_ *) { return 0; } + +template +inline type2type *encode_type(T const &, boost::mpl::true_ *) { return 0; } + +/////////////////////////////////////////////////////////////////////////////// +// set_false +// +inline bool set_false(bool &b) +{ + b = false; + return false; +} + +/////////////////////////////////////////////////////////////////////////////// +// to_ptr +// +template +inline T *&to_ptr(T const &) +{ + static T *t = 0; + return t; +} + +// Borland needs a little extra help with arrays +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +template +inline T (*&to_ptr(T (&)[N]))[N] +{ + static T (*t)[N] = 0; + return t; +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// derefof +// +template +inline T &derefof(T *t) +{ + // This is a work-around for a compiler bug in Borland. If T* is a pointer to array type U(*)[N], + // then dereferencing it results in a U* instead of U(&)[N]. The cast forces the issue. + return reinterpret_cast( + *const_cast( + reinterpret_cast(t) + ) + ); +} + +#if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION) \ + && !defined(BOOST_NO_RVALUE_REFERENCES) +/////////////////////////////////////////////////////////////////////////////// +// Rvalue references makes it drop-dead simple to detect at compile time +// whether an expression is an rvalue. +/////////////////////////////////////////////////////////////////////////////// + +# define BOOST_FOREACH_IS_RVALUE(COL) \ + boost::foreach_detail_::is_rvalue_((COL), 0) + +#elif defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION) \ + && defined(BOOST_NO_RVALUE_REFERENCES) +/////////////////////////////////////////////////////////////////////////////// +// Detect at compile-time whether an expression yields an rvalue or +// an lvalue. This is rather non-standard, but some popular compilers +// accept it. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// rvalue_probe +// +template +struct rvalue_probe +{ + struct private_type_ {}; + // can't ever return an array by value + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::mpl::or_, boost::is_array >, private_type_, T + >::type value_type; + operator value_type() { return *reinterpret_cast(this); } // never called + operator T &() const { return *reinterpret_cast(const_cast(this)); } // never called +}; + +template +rvalue_probe const make_probe(T const &) +{ + return rvalue_probe(); +} + +# define BOOST_FOREACH_IS_RVALUE(COL) \ + boost::foreach_detail_::and_( \ + boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(COL)) \ + , (true ? 0 : boost::foreach_detail_::is_rvalue_( \ + (true ? boost::foreach_detail_::make_probe(COL) : (COL)), 0))) + +#elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION) +/////////////////////////////////////////////////////////////////////////////// +// Detect at run-time whether an expression yields an rvalue +// or an lvalue. This is 100% standard C++, but not all compilers +// accept it. Also, it causes FOREACH to break when used with non- +// copyable collection types. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// rvalue_probe +// +template +struct rvalue_probe +{ + rvalue_probe(T &t, bool &b) + : value(t) + , is_rvalue(b) + { + } + + struct private_type_ {}; + // can't ever return an array or an abstract type by value + #ifdef BOOST_NO_IS_ABSTRACT + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::is_array, private_type_, T + >::type value_type; + #else + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::mpl::or_, boost::is_array >, private_type_, T + >::type value_type; + #endif + + operator value_type() + { + this->is_rvalue = true; + return this->value; + } + + operator T &() const + { + return this->value; + } + +private: + T &value; + bool &is_rvalue; +}; + +template +rvalue_probe make_probe(T &t, bool &b) { return rvalue_probe(t, b); } + +template +rvalue_probe make_probe(T const &t, bool &b) { return rvalue_probe(t, b); } + +/////////////////////////////////////////////////////////////////////////////// +// simple_variant +// holds either a T or a T const* +template +struct simple_variant +{ + simple_variant(T const *t) + : is_rvalue(false) + { + *static_cast(this->data.address()) = t; + } + + simple_variant(T const &t) + : is_rvalue(true) + { + ::new(this->data.address()) T(t); + } + + simple_variant(simple_variant const &that) + : is_rvalue(that.is_rvalue) + { + if(this->is_rvalue) + ::new(this->data.address()) T(*that.get()); + else + *static_cast(this->data.address()) = that.get(); + } + + ~simple_variant() + { + if(this->is_rvalue) + this->get()->~T(); + } + + T const *get() const + { + if(this->is_rvalue) + return static_cast(this->data.address()); + else + return *static_cast(this->data.address()); + } + +private: + enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) }; + simple_variant &operator =(simple_variant const &); + bool const is_rvalue; + aligned_storage data; +}; + +// If the collection is an array or is noncopyable, it must be an lvalue. +// If the collection is a lightweight proxy, treat it as an rvalue +// BUGBUG what about a noncopyable proxy? +template +inline BOOST_DEDUCED_TYPENAME boost::enable_if, IsProxy>::type * +should_copy_impl(LValue *, IsProxy *, bool *) +{ + return 0; +} + +// Otherwise, we must determine at runtime whether it's an lvalue or rvalue +inline bool * +should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue) +{ + return is_rvalue; +} + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// contain +// +template +inline auto_any contain(T const &t, boost::mpl::true_ *) // rvalue +{ + return auto_any(t); +} + +template +inline auto_any contain(T &t, boost::mpl::false_ *) // lvalue +{ + // Cannot seem to get sunpro to handle addressof() with array types. + #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570)) + return auto_any(&t); + #else + return auto_any(boost::addressof(t)); + #endif +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any > +contain(T const &t, bool *rvalue) +{ + return auto_any >(*rvalue ? simple_variant(t) : simple_variant(&t)); +} +#endif + +///////////////////////////////////////////////////////////////////////////// +// begin +// +template +inline auto_any::type> +begin(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( + boost::begin(auto_any_cast(col))); +} + +template +inline auto_any::type> +begin(auto_any_t col, type2type *, boost::mpl::false_ *) // lvalue +{ + typedef BOOST_DEDUCED_TYPENAME type2type::type type; + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iterator; + return auto_any::type>( + iterator(boost::begin(derefof(auto_any_cast(col))))); +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any::type> +begin(auto_any_t col, type2type *, bool *) +{ + return auto_any::type>( + boost::begin(*auto_any_cast, boost::mpl::false_>(col).get())); +} +#endif + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline auto_any +begin(auto_any_t col, type2type *, boost::mpl::true_ *) // null-terminated C-style strings +{ + return auto_any(auto_any_cast(col)); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// end +// +template +inline auto_any::type> +end(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( + boost::end(auto_any_cast(col))); +} + +template +inline auto_any::type> +end(auto_any_t col, type2type *, boost::mpl::false_ *) // lvalue +{ + typedef BOOST_DEDUCED_TYPENAME type2type::type type; + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iterator; + return auto_any::type>( + iterator(boost::end(derefof(auto_any_cast(col))))); +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any::type> +end(auto_any_t col, type2type *, bool *) +{ + return auto_any::type>( + boost::end(*auto_any_cast, boost::mpl::false_>(col).get())); +} +#endif + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline auto_any +end(auto_any_t, type2type *, boost::mpl::true_ *) // null-terminated C-style strings +{ + return auto_any(0); // not used +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// done +// +template +inline bool done(auto_any_t cur, auto_any_t end, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iter_t; + return auto_any_cast(cur) == auto_any_cast(end); +} + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline bool done(auto_any_t cur, auto_any_t, type2type *) // null-terminated C-style strings +{ + return ! *auto_any_cast(cur); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// next +// +template +inline void next(auto_any_t cur, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iter_t; + ++auto_any_cast(cur); +} + +/////////////////////////////////////////////////////////////////////////////// +// deref +// +template +inline BOOST_DEDUCED_TYPENAME foreach_reference::type +deref(auto_any_t cur, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iter_t; + return *auto_any_cast(cur); +} + +///////////////////////////////////////////////////////////////////////////// +// rbegin +// +template +inline auto_any::type> +rbegin(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 32 From noreply at r-forge.r-project.org Sat May 4 02:56:40 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 02:56:40 +0200 (CEST) Subject: [Boostheaders-commits] r33 - in pkg/BH/inst/include/boost: format fusion math/constants math/distributions math/tools/detail tr1 Message-ID: <20130504005640.9D1DE184971@r-forge.r-project.org> Author: edd Date: 2013-05-04 02:56:39 +0200 (Sat, 04 May 2013) New Revision: 33 Added: pkg/BH/inst/include/boost/format/alt_sstream.hpp pkg/BH/inst/include/boost/format/alt_sstream_impl.hpp pkg/BH/inst/include/boost/format/detail/ pkg/BH/inst/include/boost/format/exceptions.hpp pkg/BH/inst/include/boost/format/feed_args.hpp pkg/BH/inst/include/boost/format/format_class.hpp pkg/BH/inst/include/boost/format/format_fwd.hpp pkg/BH/inst/include/boost/format/format_implementation.hpp pkg/BH/inst/include/boost/format/free_funcs.hpp pkg/BH/inst/include/boost/format/group.hpp pkg/BH/inst/include/boost/format/internals.hpp pkg/BH/inst/include/boost/format/internals_fwd.hpp pkg/BH/inst/include/boost/format/parsing.hpp pkg/BH/inst/include/boost/fusion/adapted/ pkg/BH/inst/include/boost/fusion/algorithm/ pkg/BH/inst/include/boost/fusion/container/ pkg/BH/inst/include/boost/fusion/include/ pkg/BH/inst/include/boost/fusion/iterator/ pkg/BH/inst/include/boost/fusion/mpl/ pkg/BH/inst/include/boost/fusion/sequence/ pkg/BH/inst/include/boost/fusion/support/ pkg/BH/inst/include/boost/fusion/tuple.hpp pkg/BH/inst/include/boost/fusion/tuple/ pkg/BH/inst/include/boost/fusion/view/ pkg/BH/inst/include/boost/math/constants/calculate_constants.hpp pkg/BH/inst/include/boost/math/constants/constants.hpp pkg/BH/inst/include/boost/math/distributions/bernoulli.hpp pkg/BH/inst/include/boost/math/distributions/beta.hpp pkg/BH/inst/include/boost/math/distributions/binomial.hpp pkg/BH/inst/include/boost/math/distributions/cauchy.hpp pkg/BH/inst/include/boost/math/distributions/chi_squared.hpp pkg/BH/inst/include/boost/math/distributions/complement.hpp pkg/BH/inst/include/boost/math/distributions/detail/ pkg/BH/inst/include/boost/math/distributions/exponential.hpp pkg/BH/inst/include/boost/math/distributions/extreme_value.hpp pkg/BH/inst/include/boost/math/distributions/find_location.hpp pkg/BH/inst/include/boost/math/distributions/find_scale.hpp pkg/BH/inst/include/boost/math/distributions/fisher_f.hpp pkg/BH/inst/include/boost/math/distributions/fwd.hpp pkg/BH/inst/include/boost/math/distributions/gamma.hpp pkg/BH/inst/include/boost/math/distributions/geometric.hpp pkg/BH/inst/include/boost/math/distributions/hypergeometric.hpp pkg/BH/inst/include/boost/math/distributions/inverse_chi_squared.hpp pkg/BH/inst/include/boost/math/distributions/inverse_gamma.hpp pkg/BH/inst/include/boost/math/distributions/inverse_gaussian.hpp pkg/BH/inst/include/boost/math/distributions/laplace.hpp pkg/BH/inst/include/boost/math/distributions/logistic.hpp pkg/BH/inst/include/boost/math/distributions/lognormal.hpp pkg/BH/inst/include/boost/math/distributions/negative_binomial.hpp pkg/BH/inst/include/boost/math/distributions/non_central_beta.hpp pkg/BH/inst/include/boost/math/distributions/non_central_chi_squared.hpp pkg/BH/inst/include/boost/math/distributions/non_central_f.hpp pkg/BH/inst/include/boost/math/distributions/non_central_t.hpp pkg/BH/inst/include/boost/math/distributions/normal.hpp pkg/BH/inst/include/boost/math/distributions/pareto.hpp pkg/BH/inst/include/boost/math/distributions/poisson.hpp pkg/BH/inst/include/boost/math/distributions/rayleigh.hpp pkg/BH/inst/include/boost/math/distributions/skew_normal.hpp pkg/BH/inst/include/boost/math/distributions/students_t.hpp pkg/BH/inst/include/boost/math/distributions/triangular.hpp pkg/BH/inst/include/boost/math/distributions/uniform.hpp pkg/BH/inst/include/boost/math/distributions/weibull.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_10.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_11.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_12.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_13.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_14.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_15.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_16.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_17.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_18.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_19.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_2.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_20.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_3.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_4.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_5.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_6.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_7.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_8.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner1_9.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_10.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_11.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_12.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_13.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_14.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_15.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_16.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_17.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_18.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_19.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_2.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_20.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_3.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_4.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_5.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_6.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_7.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_8.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner2_9.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_10.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_11.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_12.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_13.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_14.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_15.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_16.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_17.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_18.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_19.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_2.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_20.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_3.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_4.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_5.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_6.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_7.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_8.hpp pkg/BH/inst/include/boost/math/tools/detail/polynomial_horner3_9.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_10.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_11.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_12.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_13.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_14.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_15.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_16.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_17.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_18.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_19.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_2.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_20.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_3.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_4.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_5.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_6.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_7.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_8.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner1_9.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_10.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_11.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_12.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_13.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_14.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_15.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_16.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_17.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_18.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_19.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_2.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_20.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_3.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_4.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_5.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_6.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_7.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_8.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner2_9.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_10.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_11.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_12.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_13.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_14.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_15.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_16.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_17.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_18.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_19.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_2.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_20.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_3.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_4.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_5.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_6.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_7.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_8.hpp pkg/BH/inst/include/boost/math/tools/detail/rational_horner3_9.hpp pkg/BH/inst/include/boost/tr1/detail/ pkg/BH/inst/include/boost/tr1/tuple.hpp Log: steps towards BH 1.51.0-1 with foreach and math distributions Added: pkg/BH/inst/include/boost/format/alt_sstream.hpp =================================================================== --- pkg/BH/inst/include/boost/format/alt_sstream.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/alt_sstream.hpp 2013-05-04 00:56:39 UTC (rev 33) @@ -0,0 +1,176 @@ +// ---------------------------------------------------------------------------- +// alt_sstream.hpp : alternative stringstream +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + + + +#ifndef BOOST_SK_ALT_SSTREAM_HPP +#define BOOST_SK_ALT_SSTREAM_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace io { + + template, + class Alloc=::std::allocator > + class basic_altstringbuf; + + template, + class Alloc=::std::allocator > + class basic_oaltstringstream; + + + template + class basic_altstringbuf + : public ::std::basic_streambuf + { + typedef ::std::basic_streambuf streambuf_t; + typedef typename CompatAlloc::compatible_type compat_allocator_type; + typedef typename CompatTraits::compatible_type compat_traits_type; + public: + typedef Ch char_type; + typedef Tr traits_type; + typedef typename compat_traits_type::int_type int_type; + typedef typename compat_traits_type::pos_type pos_type; + typedef typename compat_traits_type::off_type off_type; + typedef Alloc allocator_type; + typedef ::std::basic_string string_type; + typedef typename string_type::size_type size_type; + + typedef ::std::streamsize streamsize; + + + explicit basic_altstringbuf(std::ios_base::openmode mode + = std::ios_base::in | std::ios_base::out) + : putend_(NULL), is_allocated_(false), mode_(mode) + {} + explicit basic_altstringbuf(const string_type& s, + ::std::ios_base::openmode mode + = ::std::ios_base::in | ::std::ios_base::out) + : putend_(NULL), is_allocated_(false), mode_(mode) + { dealloc(); str(s); } + virtual ~basic_altstringbuf() + { dealloc(); } + using streambuf_t::pbase; + using streambuf_t::pptr; + using streambuf_t::epptr; + using streambuf_t::eback; + using streambuf_t::gptr; + using streambuf_t::egptr; + + void clear_buffer(); + void str(const string_type& s); + + // 0-copy access : + Ch * begin() const; + size_type size() const; + size_type cur_size() const; // stop at current pointer + Ch * pend() const // the highest position reached by pptr() since creation + { return ((putend_ < pptr()) ? pptr() : putend_); } + size_type pcount() const + { return static_cast( pptr() - pbase()) ;} + + // copy buffer to string : + string_type str() const + { return string_type(begin(), size()); } + string_type cur_str() const + { return string_type(begin(), cur_size()); } + protected: + explicit basic_altstringbuf (basic_altstringbuf * s, + ::std::ios_base::openmode mode + = ::std::ios_base::in | ::std::ios_base::out) + : putend_(NULL), is_allocated_(false), mode_(mode) + { dealloc(); str(s); } + + virtual pos_type seekoff(off_type off, ::std::ios_base::seekdir way, + ::std::ios_base::openmode which + = ::std::ios_base::in | ::std::ios_base::out); + virtual pos_type seekpos (pos_type pos, + ::std::ios_base::openmode which + = ::std::ios_base::in | ::std::ios_base::out); + virtual int_type underflow(); + virtual int_type pbackfail(int_type meta = compat_traits_type::eof()); + virtual int_type overflow(int_type meta = compat_traits_type::eof()); + void dealloc(); + private: + enum { alloc_min = 256}; // minimum size of allocations + + Ch *putend_; // remembers (over seeks) the highest value of pptr() + bool is_allocated_; + ::std::ios_base::openmode mode_; + compat_allocator_type alloc_; // the allocator object + }; + + +// --- class basic_oaltstringstream ---------------------------------------- + template + class basic_oaltstringstream + : private base_from_member< shared_ptr< basic_altstringbuf< Ch, Tr, Alloc> > >, + public ::std::basic_ostream + { + class No_Op { + // used as no-op deleter for (not-owner) shared_pointers + public: + template + const T & operator()(const T & arg) { return arg; } + }; + typedef ::std::basic_ostream stream_t; + typedef boost::base_from_member > > + pbase_type; + typedef ::std::basic_string string_type; + typedef typename string_type::size_type size_type; + typedef basic_altstringbuf stringbuf_t; + public: + typedef Alloc allocator_type; + basic_oaltstringstream() + : pbase_type(new stringbuf_t), stream_t(rdbuf()) + { } + basic_oaltstringstream(::boost::shared_ptr buf) + : pbase_type(buf), stream_t(rdbuf()) + { } + basic_oaltstringstream(stringbuf_t * buf) + : pbase_type(buf, No_Op() ), stream_t(rdbuf()) + { } + stringbuf_t * rdbuf() const + { return pbase_type::member.get(); } + void clear_buffer() + { rdbuf()->clear_buffer(); } + + // 0-copy access : + Ch * begin() const + { return rdbuf()->begin(); } + size_type size() const + { return rdbuf()->size(); } + size_type cur_size() const // stops at current position + { return rdbuf()->cur_size(); } + + // copy buffer to string : + string_type str() const // [pbase, epptr[ + { return rdbuf()->str(); } + string_type cur_str() const // [pbase, pptr[ + { return rdbuf()->cur_str(); } + void str(const string_type& s) + { rdbuf()->str(s); } + }; + + } // N.S. io +} // N.S. boost + +#include + +#endif // include guard + Added: pkg/BH/inst/include/boost/format/alt_sstream_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/format/alt_sstream_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/alt_sstream_impl.hpp 2013-05-04 00:56:39 UTC (rev 33) @@ -0,0 +1,313 @@ +// ---------------------------------------------------------------------------- +// alt_sstream_impl.hpp : alternative stringstream, templates implementation +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_SK_ALT_SSTREAM_IMPL_HPP +#define BOOST_SK_ALT_SSTREAM_IMPL_HPP + +namespace boost { + namespace io { +// --- Implementation ------------------------------------------------------// + + template + void basic_altstringbuf:: + clear_buffer () { + const Ch * p = pptr(); + const Ch * b = pbase(); + if(p != NULL && p != b) { + seekpos(0, ::std::ios_base::out); + } + p = gptr(); + b = eback(); + if(p != NULL && p != b) { + seekpos(0, ::std::ios_base::in); + } + } + + template + void basic_altstringbuf:: + str (const string_type& s) { + size_type sz=s.size(); + if(sz != 0 && mode_ & (::std::ios_base::in | ::std::ios_base::out) ) { +#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC + void *vd_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0); + Ch *new_ptr = static_cast(vd_ptr); +#else + Ch *new_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0); +#endif + // if this didnt throw, we're safe, update the buffer + dealloc(); + sz = s.copy(new_ptr, sz); + putend_ = new_ptr + sz; + if(mode_ & ::std::ios_base::in) + streambuf_t::setg(new_ptr, new_ptr, new_ptr + sz); + if(mode_ & ::std::ios_base::out) { + streambuf_t::setp(new_ptr, new_ptr + sz); + if(mode_ & (::std::ios_base::app | ::std::ios_base::ate)) + streambuf_t::pbump(static_cast(sz)); + if(gptr() == NULL) + streambuf_t::setg(new_ptr, NULL, new_ptr); + } + is_allocated_ = true; + } + else + dealloc(); + } + template + Ch* basic_altstringbuf:: + begin () const { + if(mode_ & ::std::ios_base::out && pptr() != NULL) + return pbase(); + else if(mode_ & ::std::ios_base::in && gptr() != NULL) + return eback(); + return NULL; + } + + template + typename std::basic_string::size_type + basic_altstringbuf:: + size () const { + if(mode_ & ::std::ios_base::out && pptr()) + return static_cast(pend() - pbase()); + else if(mode_ & ::std::ios_base::in && gptr()) + return static_cast(egptr() - eback()); + else + return 0; + } + + template + typename std::basic_string::size_type + basic_altstringbuf:: + cur_size () const { + if(mode_ & ::std::ios_base::out && pptr()) + return static_cast( pptr() - pbase()); + else if(mode_ & ::std::ios_base::in && gptr()) + return static_cast( gptr() - eback()); + else + return 0; + } + + template + typename basic_altstringbuf::pos_type + basic_altstringbuf:: + seekoff (off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) { + if(pptr() != NULL && putend_ < pptr()) + putend_ = pptr(); + if(which & ::std::ios_base::in && gptr() != NULL) { + // get area + if(way == ::std::ios_base::end) + off += static_cast(putend_ - gptr()); + else if(way == ::std::ios_base::beg) + off += static_cast(eback() - gptr()); + else if(way != ::std::ios_base::cur || (which & ::std::ios_base::out) ) + // (altering in&out is only supported if way is beg or end, not cur) + return pos_type(off_type(-1)); + if(eback() <= off+gptr() && off+gptr() <= putend_ ) { + // set gptr + streambuf_t::gbump(static_cast(off)); + if(which & ::std::ios_base::out && pptr() != NULL) + // update pptr to match gptr + streambuf_t::pbump(static_cast(gptr()-pptr())); + } + else + off = off_type(-1); + } + else if(which & ::std::ios_base::out && pptr() != NULL) { + // put area + if(way == ::std::ios_base::end) + off += static_cast(putend_ - pptr()); + else if(way == ::std::ios_base::beg) + off += static_cast(pbase() - pptr()); + else if(way != ::std::ios_base::beg) + return pos_type(off_type(-1)); + if(pbase() <= off+pptr() && off+pptr() <= putend_) + // set pptr + streambuf_t::pbump(static_cast(off)); + else + off = off_type(-1); + } + else // neither in nor out + off = off_type(-1); + return (pos_type(off)); + } + //- end seekoff(..) + + + template + typename basic_altstringbuf::pos_type + basic_altstringbuf:: + seekpos (pos_type pos, ::std::ios_base::openmode which) { + off_type off = off_type(pos); // operation guaranteed by 27.4.3.2 table 88 + if(pptr() != NULL && putend_ < pptr()) + putend_ = pptr(); + if(off != off_type(-1)) { + if(which & ::std::ios_base::in && gptr() != NULL) { + // get area + if(0 <= off && off <= putend_ - eback()) { + streambuf_t::gbump(static_cast(eback() - gptr() + off)); + if(which & ::std::ios_base::out && pptr() != NULL) { + // update pptr to match gptr + streambuf_t::pbump(static_cast(gptr()-pptr())); + } + } + else + off = off_type(-1); + } + else if(which & ::std::ios_base::out && pptr() != NULL) { + // put area + if(0 <= off && off <= putend_ - eback()) + streambuf_t::pbump(static_cast(eback() - pptr() + off)); + else + off = off_type(-1); + } + else // neither in nor out + off = off_type(-1); + return (pos_type(off)); + } + else { + BOOST_ASSERT(0); // ?27.4.3.2 allows undefined-behaviour here + return pos_type(off_type(-1)); + } + } + // -end seekpos(..) + + + template + typename basic_altstringbuf::int_type + basic_altstringbuf:: + underflow () { + if(gptr() == NULL) // no get area -> nothing to get. + return (compat_traits_type::eof()); + else if(gptr() < egptr()) // ok, in buffer + return (compat_traits_type::to_int_type(*gptr())); + else if(mode_ & ::std::ios_base::in && pptr() != NULL + && (gptr() < pptr() || gptr() < putend_) ) + { // expand get area + if(putend_ < pptr()) + putend_ = pptr(); // remember pptr reached this far + streambuf_t::setg(eback(), gptr(), putend_); + return (compat_traits_type::to_int_type(*gptr())); + } + else // couldnt get anything. EOF. + return (compat_traits_type::eof()); + } + // -end underflow(..) + + + template + typename basic_altstringbuf::int_type + basic_altstringbuf:: + pbackfail (int_type meta) { + if(gptr() != NULL && (eback() < gptr()) + && (mode_ & (::std::ios_base::out) + || compat_traits_type::eq_int_type(compat_traits_type::eof(), meta) + || compat_traits_type::eq(compat_traits_type::to_char_type(meta), gptr()[-1]) ) ) { + streambuf_t::gbump(-1); // back one character + if(!compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)) + // put-back meta into get area + *gptr() = compat_traits_type::to_char_type(meta); + return (compat_traits_type::not_eof(meta)); + } + else + return (compat_traits_type::eof()); // failed putback + } + // -end pbackfail(..) + + + template + typename basic_altstringbuf::int_type + basic_altstringbuf:: + overflow (int_type meta) { +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4996) +#endif + if(compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)) + return compat_traits_type::not_eof(meta); // nothing to do + else if(pptr() != NULL && pptr() < epptr()) { + streambuf_t::sputc(compat_traits_type::to_char_type(meta)); + return meta; + } + else if(! (mode_ & ::std::ios_base::out)) + // no write position, and cant make one + return compat_traits_type::eof(); + else { // make a write position available + std::size_t prev_size = pptr() == NULL ? 0 : epptr() - eback(); + std::size_t new_size = prev_size; + // exponential growth : size *= 1.5 + std::size_t add_size = new_size / 2; + if(add_size < alloc_min) + add_size = alloc_min; + Ch * newptr = NULL, *oldptr = eback(); + + // make sure adding add_size wont overflow size_t + while (0 < add_size && ((std::numeric_limits::max)() + - add_size < new_size) ) + add_size /= 2; + if(0 < add_size) { + new_size += add_size; +#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC + void *vdptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0); + newptr = static_cast(vdptr); +#else + newptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0); +#endif + } + + if(0 < prev_size) + compat_traits_type::copy(newptr, oldptr, prev_size); + if(is_allocated_) + alloc_.deallocate(oldptr, prev_size); + is_allocated_=true; + + if(prev_size == 0) { // first allocation + putend_ = newptr; + streambuf_t::setp(newptr, newptr + new_size); + if(mode_ & ::std::ios_base::in) + streambuf_t::setg(newptr, newptr, newptr + 1); + else + streambuf_t::setg(newptr, 0, newptr); + } + else { // update pointers + putend_ = putend_ - oldptr + newptr; + int pptr_count = static_cast(pptr()-pbase()); + int gptr_count = static_cast(gptr()-eback()); + streambuf_t::setp(pbase() - oldptr + newptr, newptr + new_size); + streambuf_t::pbump(pptr_count); + if(mode_ & ::std::ios_base::in) + streambuf_t::setg(newptr, newptr + gptr_count, pptr() + 1); + else + streambuf_t::setg(newptr, 0, newptr); + } + streambuf_t::sputc(compat_traits_type::to_char_type(meta)); + return meta; + } +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + } + // -end overflow(..) + + template + void basic_altstringbuf:: dealloc() { + if(is_allocated_) + alloc_.deallocate(eback(), (pptr() != NULL ? epptr() : egptr()) - eback()); + is_allocated_ = false; + streambuf_t::setg(0, 0, 0); + streambuf_t::setp(0, 0); + putend_ = NULL; + } + + }// N.S. io +} // N.S. boost + +#endif // include guard + Added: pkg/BH/inst/include/boost/format/exceptions.hpp =================================================================== --- pkg/BH/inst/include/boost/format/exceptions.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/exceptions.hpp 2013-05-04 00:56:39 UTC (rev 33) @@ -0,0 +1,103 @@ +// ---------------------------------------------------------------------------- +// boost/format/exceptions.hpp +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 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/format/ for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_EXCEPTIONS_HPP +#define BOOST_FORMAT_EXCEPTIONS_HPP + + +#include + + +namespace boost { + + namespace io { + +// **** exceptions ----------------------------------------------- + + class format_error : public std::exception + { + public: + format_error() {} + virtual const char *what() const throw() { + return "boost::format_error: " + "format generic failure"; + } + }; + + class bad_format_string : public format_error + { + std::size_t pos_, next_; + public: + bad_format_string(std::size_t pos, std::size_t size) + : pos_(pos), next_(size) {} + std::size_t get_pos() const { return pos_; } + std::size_t get_next() const { return next_; } + virtual const char *what() const throw() { + return "boost::bad_format_string: format-string is ill-formed"; + } + }; + + class too_few_args : public format_error + { + std::size_t cur_, expected_; + public: + too_few_args(std::size_t cur, std::size_t expected) + : cur_(cur), expected_(expected) {} + std::size_t get_cur() const { return cur_; } + std::size_t get_expected() const { return expected_; } + virtual const char *what() const throw() { + return "boost::too_few_args: " + "format-string referred to more arguments than were passed"; + } + }; + + class too_many_args : public format_error + { + std::size_t cur_, expected_; + public: + too_many_args(std::size_t cur, std::size_t expected) + : cur_(cur), expected_(expected) {} + std::size_t get_cur() const { return cur_; } + std::size_t get_expected() const { return expected_; } + virtual const char *what() const throw() { + return "boost::too_many_args: " + "format-string referred to less arguments than were passed"; + } + }; + + + class out_of_range : public format_error + { + int index_, beg_, end_; // range is [ beg, end [ + public: + out_of_range(int index, int beg, int end) + : index_(index), beg_(beg), end_(end) {} + int get_index() const { return index_; } + int get_beg() const { return beg_; } + int get_end() const { return end_; } + virtual const char *what() const throw() { + return "boost::out_of_range: " + "tried to refer to an argument (or item) number which" + " is out of range, according to the format string"; + } + }; + + + } // namespace io + +} // namespace boost + + +#endif // BOOST_FORMAT_EXCEPTIONS_HPP Added: pkg/BH/inst/include/boost/format/feed_args.hpp =================================================================== --- pkg/BH/inst/include/boost/format/feed_args.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/feed_args.hpp 2013-05-04 00:56:39 UTC (rev 33) @@ -0,0 +1,277 @@ +// ---------------------------------------------------------------------------- +// feed_args.hpp : functions for processing each argument +// (feed, feed_manip, and distribute) +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_FEED_ARGS_HPP +#define BOOST_FORMAT_FEED_ARGS_HPP + +#include +#include +#include + +#include +#include +#include + +namespace boost { +namespace io { +namespace detail { + + template + void mk_str( std::basic_string & res, + const Ch * beg, + typename std::basic_string::size_type size, + std::streamsize w, + const Ch fill_char, + std::ios_base::fmtflags f, + const Ch prefix_space, // 0 if no space-padding + bool center) + // applies centered/left/right padding to the string [beg, beg+size[ + // Effects : the result is placed in res. + { + typedef typename std::basic_string::size_type size_type; + res.resize(0); + if(w<=0 || static_cast(w) <=size) { + // no need to pad. + res.reserve(size + !!prefix_space); + if(prefix_space) + res.append(1, prefix_space); + if (size) + res.append(beg, size); + } + else { + std::streamsize n=static_cast(w-size-!!prefix_space); + std::streamsize n_after = 0, n_before = 0; + res.reserve(static_cast(w)); // allocate once for the 2 inserts + if(center) + n_after = n/2, n_before = n - n_after; + else + if(f & std::ios_base::left) + n_after = n; + else + n_before = n; + // now make the res string : + if(n_before) res.append(static_cast(n_before), fill_char); + if(prefix_space) + res.append(1, prefix_space); + if (size) + res.append(beg, size); + if(n_after) res.append(static_cast(n_after), fill_char); + } + } // -mk_str(..) + + +#if BOOST_WORKAROUND( BOOST_MSVC, <= 1300) || \ + BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) +// MSVC needs to be tricked to disambiguate this simple overload.. +// the trick is in "boost/format/msvc_disambiguater.hpp" + + template< class Ch, class Tr, class T> inline + void put_head (BOOST_IO_STD basic_ostream & os, const T& x ) { + disambiguater::put_head(os, x, 1L); + } + template< class Ch, class Tr, class T> inline + void put_last (BOOST_IO_STD basic_ostream & os, const T& x ) { + disambiguater::put_last(os, x, 1L); + } + +#else + + template< class Ch, class Tr, class T> inline + void put_head (BOOST_IO_STD basic_ostream &, const T& ) { + } + + template< class Ch, class Tr, class T> inline + void put_head( BOOST_IO_STD basic_ostream & os, const group1& x ) { + os << group_head(x.a1_); // send the first N-1 items, not the last + } + + template< class Ch, class Tr, class T> inline + void put_last( BOOST_IO_STD basic_ostream & os, const T& x ) { + os << x ; + } + + template< class Ch, class Tr, class T> inline + void put_last( BOOST_IO_STD basic_ostream & os, const group1& x ) { + os << group_last(x.a1_); // this selects the last element + } + +#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST + template< class Ch, class Tr, class T> inline + void put_head( BOOST_IO_STD basic_ostream &, T& ) { + } + + template< class Ch, class Tr, class T> inline + void put_last( BOOST_IO_STD basic_ostream & os, T& x) { + os << x ; + } +#endif +#endif // -msvc workaround + + + template< class Ch, class Tr, class Alloc, class T> + void put( T x, + const format_item& specs, + typename basic_format::string_type& res, + typename basic_format::internal_streambuf_t & buf, + io::detail::locale_t *loc_p = NULL) + { +#ifdef BOOST_MSVC + // If std::min or std::max are already instantiated + // at this point then we get a blizzard of warning messages when we call + // those templates with std::size_t as arguments. Weird and very annoyning... +#pragma warning(push) +#pragma warning(disable:4267) +#endif + // does the actual conversion of x, with given params, into a string + // using the supplied stringbuf. + + typedef typename basic_format::string_type string_type; + typedef typename basic_format::format_item_t format_item_t; + typedef typename string_type::size_type size_type; + + basic_oaltstringstream oss( &buf); + specs.fmtstate_.apply_on(oss, loc_p); + + // the stream format state can be modified by manipulators in the argument : + put_head( oss, x ); + // in case x is a group, apply the manip part of it, + // in order to find width + + const std::ios_base::fmtflags fl=oss.flags(); + const bool internal = (fl & std::ios_base::internal) != 0; + const std::streamsize w = oss.width(); + const bool two_stepped_padding= internal && (w!=0); + + res.resize(0); + if(! two_stepped_padding) { + if(w>0) // handle padding via mk_str, not natively in stream + oss.width(0); + put_last( oss, x); + const Ch * res_beg = buf.pbase(); + Ch prefix_space = 0; + if(specs.pad_scheme_ & format_item_t::spacepad) + if(buf.pcount()== 0 || + (res_beg[0] !=oss.widen('+') && res_beg[0] !=oss.widen('-') )) + prefix_space = oss.widen(' '); + size_type res_size = (std::min)( + static_cast(specs.truncate_ - !!prefix_space), + buf.pcount() ); + mk_str(res, res_beg, res_size, w, oss.fill(), fl, + prefix_space, (specs.pad_scheme_ & format_item_t::centered) !=0 ); + } + else { // 2-stepped padding + // internal can be implied by zeropad, or user-set. + // left, right, and centered alignment overrule internal, + // but spacepad or truncate might be mixed with internal (using manipulator) + put_last( oss, x); // may pad + const Ch * res_beg = buf.pbase(); [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 33 From noreply at r-forge.r-project.org Sat May 4 02:57:24 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 02:57:24 +0200 (CEST) Subject: [Boostheaders-commits] r34 - in pkg/BH/inst/include/boost: format/detail fusion/adapted fusion/algorithm fusion/container fusion/include fusion/iterator fusion/mpl fusion/sequence fusion/support fusion/tuple fusion/view math/distributions/detail tr1/detail Message-ID: <20130504005724.DA04F184971@r-forge.r-project.org> Author: edd Date: 2013-05-04 02:57:24 +0200 (Sat, 04 May 2013) New Revision: 34 Added: pkg/BH/inst/include/boost/format/detail/compat_workarounds.hpp pkg/BH/inst/include/boost/format/detail/config_macros.hpp pkg/BH/inst/include/boost/format/detail/msvc_disambiguater.hpp pkg/BH/inst/include/boost/format/detail/unset_macros.hpp pkg/BH/inst/include/boost/format/detail/workarounds_gcc-2_95.hpp pkg/BH/inst/include/boost/format/detail/workarounds_stlport.hpp pkg/BH/inst/include/boost/fusion/adapted/mpl/ pkg/BH/inst/include/boost/fusion/adapted/std_pair.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/ pkg/BH/inst/include/boost/fusion/algorithm/transformation/ pkg/BH/inst/include/boost/fusion/container/generation/ pkg/BH/inst/include/boost/fusion/container/list/ pkg/BH/inst/include/boost/fusion/container/vector/ pkg/BH/inst/include/boost/fusion/include/std_pair.hpp pkg/BH/inst/include/boost/fusion/include/tuple.hpp pkg/BH/inst/include/boost/fusion/iterator/advance.hpp pkg/BH/inst/include/boost/fusion/iterator/basic_iterator.hpp pkg/BH/inst/include/boost/fusion/iterator/deref.hpp pkg/BH/inst/include/boost/fusion/iterator/deref_data.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/ pkg/BH/inst/include/boost/fusion/iterator/distance.hpp pkg/BH/inst/include/boost/fusion/iterator/equal_to.hpp pkg/BH/inst/include/boost/fusion/iterator/iterator_facade.hpp pkg/BH/inst/include/boost/fusion/iterator/key_of.hpp pkg/BH/inst/include/boost/fusion/iterator/mpl/ pkg/BH/inst/include/boost/fusion/iterator/next.hpp pkg/BH/inst/include/boost/fusion/iterator/prior.hpp pkg/BH/inst/include/boost/fusion/iterator/segmented_iterator.hpp pkg/BH/inst/include/boost/fusion/iterator/value_of.hpp pkg/BH/inst/include/boost/fusion/iterator/value_of_data.hpp pkg/BH/inst/include/boost/fusion/mpl/begin.hpp pkg/BH/inst/include/boost/fusion/mpl/end.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/ pkg/BH/inst/include/boost/fusion/sequence/intrinsic/ pkg/BH/inst/include/boost/fusion/sequence/intrinsic_fwd.hpp pkg/BH/inst/include/boost/fusion/sequence/io.hpp pkg/BH/inst/include/boost/fusion/sequence/io/ pkg/BH/inst/include/boost/fusion/support/as_const.hpp pkg/BH/inst/include/boost/fusion/support/category_of.hpp pkg/BH/inst/include/boost/fusion/support/detail/ pkg/BH/inst/include/boost/fusion/support/is_iterator.hpp pkg/BH/inst/include/boost/fusion/support/is_segmented.hpp pkg/BH/inst/include/boost/fusion/support/is_sequence.hpp pkg/BH/inst/include/boost/fusion/support/is_view.hpp pkg/BH/inst/include/boost/fusion/support/iterator_base.hpp pkg/BH/inst/include/boost/fusion/support/sequence_base.hpp pkg/BH/inst/include/boost/fusion/support/tag_of.hpp pkg/BH/inst/include/boost/fusion/support/tag_of_fwd.hpp pkg/BH/inst/include/boost/fusion/support/void.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/ pkg/BH/inst/include/boost/fusion/tuple/make_tuple.hpp pkg/BH/inst/include/boost/fusion/tuple/tuple.hpp pkg/BH/inst/include/boost/fusion/tuple/tuple_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/tuple_tie.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/ pkg/BH/inst/include/boost/fusion/view/joint_view/ pkg/BH/inst/include/boost/fusion/view/single_view/ pkg/BH/inst/include/boost/math/distributions/detail/common_error_handling.hpp pkg/BH/inst/include/boost/math/distributions/detail/derived_accessors.hpp pkg/BH/inst/include/boost/math/distributions/detail/generic_mode.hpp pkg/BH/inst/include/boost/math/distributions/detail/generic_quantile.hpp pkg/BH/inst/include/boost/math/distributions/detail/hypergeometric_cdf.hpp pkg/BH/inst/include/boost/math/distributions/detail/hypergeometric_pdf.hpp pkg/BH/inst/include/boost/math/distributions/detail/hypergeometric_quantile.hpp pkg/BH/inst/include/boost/math/distributions/detail/inv_discrete_quantile.hpp pkg/BH/inst/include/boost/tr1/detail/config.hpp pkg/BH/inst/include/boost/tr1/detail/config_all.hpp Log: steps towards BH 1.51.0-1 with foreach and math distributions Added: pkg/BH/inst/include/boost/format/detail/compat_workarounds.hpp =================================================================== --- pkg/BH/inst/include/boost/format/detail/compat_workarounds.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/detail/compat_workarounds.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,86 @@ +// ---------------------------------------------------------------------------- +// compat_workarounds : general framework for non-conformance workarounds +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + + +// this file defines wrapper classes to hide non-conforming +// std::char_traits<> and std::allocator<> traits +// and Includes : config_macros.hpp (defines config macros +// and compiler-specific switches) + +// Non-conformant Std-libs fail to supply conformant traits (std::char_traits, +// std::allocator) and/or the std::string doesnt support them. +// We don't want to have hundreds of #ifdef workarounds, so we define +// replacement traits. +// But both char_traits and allocator traits are visible in the interface, +// (inside the final string type), thus we need to keep both +// the replacement type (typedefed to 'compatible_type') for real use, +// and the original stdlib type (typedef to 'type_for_string') for interface +// visibility. This is what Compat* classes do (as well as be transparent +// when good allocator and char traits are present) + +#ifndef BOOST_FORMAT_COMPAT_WORKAROUNDS_HPP +#define BOOST_FORMAT_COMPAT_WORKAROUNDS_HPP + +namespace boost { + namespace io { + + // gcc-2.95 char traits (non-conformantly named string_char_traits) + // lack several functions so we extend them in a replacement class. + template + class CompatTraits; + + // std::allocator in gcc-2.95 is ok, but basic_string only works + // with plain 'std::alloc' still, alt_stringbuf requires a functionnal + // alloc template argument, so we need a replacement allocator + template + class CompatAlloc; + } // N.S. io +}// N.S. boost + + +#include + // sets-up macros and load compiler-specific workarounds headers. + +#if !defined(BOOST_FORMAT_STREAMBUF_DEFINED) +// workarounds-gcc-2.95 might have defined own streambuf +#include +#endif + +#if !defined(BOOST_FORMAT_OSTREAM_DEFINED) +// workarounds-gcc-2.95 might already have included +#include +#endif + + + +namespace boost { + namespace io { + + // **** CompatTraits general definitions : ---------------------------- + template + class CompatTraits + { // general case : be transparent + public: + typedef Tr compatible_type; + }; + + // **** CompatAlloc general definitions : ----------------------------- + template + class CompatAlloc + { // general case : be transparent + public: + typedef Alloc compatible_type; + }; + + } //N.S. io +} // N.S. boost +#endif // include guard Added: pkg/BH/inst/include/boost/format/detail/config_macros.hpp =================================================================== --- pkg/BH/inst/include/boost/format/detail/config_macros.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/detail/config_macros.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,97 @@ +// -*- C++ -*- +// ---------------------------------------------------------------------------- +// config_macros.hpp : configuration macros for the format library +// only BOOST_IO_STD is absolutely needed (it should be 'std::' in general) +// others are compiler-specific workaround macros used in #ifdef switches +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_CONFIG_MACROS_HPP +#define BOOST_FORMAT_CONFIG_MACROS_HPP + +#include +#include + +// make sure our local macros wont override something : +#if defined(BOOST_NO_LOCALE_ISDIGIT) || defined(BOOST_OVERLOAD_FOR_NON_CONST) \ + || defined(BOOST_IO_STD) || defined( BOOST_IO_NEEDS_USING_DECLARATION ) \ + || defined(BOOST_NO_TEMPLATE_STD_STREAM) \ + || defined(BOOST_FORMAT_STREAMBUF_DEFINED) || defined(BOOST_FORMAT_OSTREAM_DEFINED) +#error "boost::format uses a local macro that is already defined." +#endif + +// specific workarounds. each header can define BOOS_IO_STD if it +// needs. (e.g. because of IO_NEEDS_USING_DECLARATION) +#include +#include + +#ifndef BOOST_IO_STD +# define BOOST_IO_STD ::std:: +#endif + +#if defined(BOOST_NO_STD_LOCALE) || \ + ( BOOST_WORKAROUND(__BORLANDC__, <= 0x564) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x570 ) ) ) +// some future __BORLANDC__ >0x564 versions might not need this +// 0x570 is Borland's kylix branch +#define BOOST_NO_LOCALE_ISDIGIT +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570) ) || BOOST_WORKAROUND( BOOST_MSVC, BOOST_TESTED_AT(1300)) +#define BOOST_NO_OVERLOAD_FOR_NON_CONST +#endif + +// gcc-2.95's native stringstream is not usable +#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) +#define BOOST_FORMAT_IGNORE_STRINGSTREAM +#endif + + +// **** Workaround for io streams, stlport and msvc. +#ifdef BOOST_IO_NEEDS_USING_DECLARATION +namespace boost { + using std::char_traits; + using std::basic_ostream; + namespace io { + using std::basic_ostream; + namespace detail { + using std::basic_ios; + using std::basic_ostream; + } + } +#if ! defined(BOOST_NO_STD_LOCALE) + using std::locale; + namespace io { + using std::locale; + namespace detail { + using std::locale; + } + } +#endif // locale +} + // -end N.S. boost +#endif // needs_using_declaration + + +// *** hide std::locale if it doesnt exist. +// this typedef is either std::locale or int, avoids placing ifdefs everywhere +namespace boost { namespace io { namespace detail { +#if ! defined(BOOST_NO_STD_LOCALE) + typedef BOOST_IO_STD locale locale_t; +#else + typedef int locale_t; +#endif +} } } + + +// ---------------------------------------------------------------------------- + +#endif // BOOST_FORMAT_MACROS_DEFAULT_HPP Added: pkg/BH/inst/include/boost/format/detail/msvc_disambiguater.hpp =================================================================== --- pkg/BH/inst/include/boost/format/detail/msvc_disambiguater.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/detail/msvc_disambiguater.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,56 @@ +// ---------------------------------------------------------------------------- +// msvc_disambiguater.hpp : msvc workarounds. (for put_{head|last} overloads) +// the trick was described in boost's list by Aleksey Gurtovoy +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_MSVC_DISAMBIGUATER_HPP +#define BOOST_MSVC_DISAMBIGUATER_HPP + +#if BOOST_WORKAROUND( BOOST_MSVC, <= 1300) || \ + BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) + // this whole header is specifically for msvc up to 7.0 + +#include +#include + +namespace boost { +namespace io { +namespace detail { + +template< class Ch, class Tr, class T > +struct disambiguater +{ + template< typename U > + static void put_head(BOOST_IO_STD basic_ostream& os, group1 const& x, long) + { + os << group_head(x.a1_); + } + static void put_head(BOOST_IO_STD basic_ostream& os, T const& x, int) + { + } + template< typename U > + static void put_last(BOOST_IO_STD basic_ostream& os, group1 const& x, long) + { + os << group_last(x.a1_); + } + static void put_last(BOOST_IO_STD basic_ostream& os, T const& x, int) + { + os << x; + } +}; + +} // namespace detail +} // namespace io +} // namespace boost + +#endif // -BOOST_MSVC + +#endif // -BOOST_MSVC_DISAMBIGUATER_HPP Added: pkg/BH/inst/include/boost/format/detail/unset_macros.hpp =================================================================== --- pkg/BH/inst/include/boost/format/detail/unset_macros.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/detail/unset_macros.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,34 @@ +// ---------------------------------------------------------------------------- +// unset_macros.hpp +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + +// *** Undefine 'local' macros : +#ifdef BOOST_NO_OVERLOAD_FOR_NON_CONST +#undef BOOST_NO_OVERLOAD_FOR_NON_CONST +#endif +#ifdef BOOST_NO_LOCALE_ISDIGIT +#undef BOOST_NO_LOCALE_ISDIGIT +#endif +#ifdef BOOST_IO_STD +#undef BOOST_IO_STD +#endif +#ifdef BOOST_IO_NEEDS_USING_DECLARATION +#undef BOOST_IO_NEEDS_USING_DECLARATION +#endif +#ifdef BOOST_NO_TEMPLATE_STD_STREAM +#undef BOOST_NO_TEMPLATE_STD_STREAM +#endif +#ifdef BOOST_FORMAT_STREAMBUF_DEFINED +#undef BOOST_FORMAT_STREAMBUF_DEFINED +#endif +#ifdef BOOST_FORMAT_OSTREAM_DEFINED +#undef BOOST_FORMAT_OSTREAM_DEFINED +#endif Added: pkg/BH/inst/include/boost/format/detail/workarounds_gcc-2_95.hpp =================================================================== --- pkg/BH/inst/include/boost/format/detail/workarounds_gcc-2_95.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/detail/workarounds_gcc-2_95.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,162 @@ +// ---------------------------------------------------------------------------- +// workarounds for gcc < 3.0. +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + + +// ---------------------------------------------------------------------------- + +// There's a lot to do, the stdlib shipped with gcc prior to 3.x +// was terribly non-conforming. +// . defines macros switches +// . supplies template classes basic_foo where gcc only supplies foo. +// i.e : +// - basic_ios from ios +// - basic_ostream from ostream +// - basic_srteambuf from streambuf +// these can be used transparently. (it obviously does not work for wchar_t) +// . specialise CompatAlloc and CompatTraits to wrap gcc-2.95's +// string_char_traits and std::alloc + +#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) + // only for gcc-2.95's native stdlib + +#ifndef BOOST_FORMAT_WORKAROUNDS_GCC295_H +#define BOOST_FORMAT_WORKAROUNDS_GCC295_H + +// SGI STL doesnt have and others, so we need iostream. +#include +#define BOOST_FORMAT_OSTREAM_DEFINED + +#include +#define BOOST_FORMAT_STREAMBUF_DEFINED + +#define BOOST_NO_TEMPLATE_STD_STREAM + +#ifndef BOOST_IO_STD +# define BOOST_IO_STD std:: +#endif + + + +// *** +// gcc's simple classes turned into standard-like template classes : + +namespace std { + + + // gcc has string_char_traits, it's incomplete. + // we declare a std::char_traits, and specialize CompatTraits<..> on it + // to do what is required + template + class char_traits; // no definition here, we will just use it as a tag. + + template + class basic_streambuf; + + template + class basic_streambuf : public streambuf { + }; + + template > + class basic_ios; + + template + class basic_ios : public ostream { + public: + basic_ios(streambuf * p) : ostream(p) {}; + char fill() const { return ios::fill(); } // gcc returns wchar.. + char fill(char c) { return ios::fill(c); } // gcc takes wchar.. + char widen(char c) { return c; } + char narrow(char c, char def) { return c; } + basic_ios& copyfmt(const ios& right) { + fill(right.fill()); + flags(right.flags() ); + exceptions(right.exceptions()); + width(right.width()); + precision(right.precision()); + return *this; + } + }; + + + typedef ios ios_base; + + template + class basic_ostream; + + template + class basic_ostream : public basic_ios + { + public: + basic_ostream(streambuf * p) : basic_ios (p) {} + }; + +} // namespace std + + +namespace boost { + namespace io { + + + // ** CompatTraits gcc2.95 specialisations ---------------------------- + template + class CompatTraits< ::std::string_char_traits > + : public ::std::string_char_traits + { + public: + typedef CompatTraits compatible_type; + + typedef Ch char_type; + typedef int int_type; + typedef ::std::streampos pos_type; + typedef ::std::streamoff off_type; + + static char_type + to_char_type(const int_type& meta) { + return static_cast(meta); } + static int_type + to_int_type(const char_type& ch) { + return static_cast(static_cast(ch) );} + static bool + eq_int_type(const int_type& left, const int_type& right) { + return left == right; } + static int_type + eof() { + return static_cast(EOF); + } + static int_type + not_eof(const int_type& meta) { + return (meta == eof()) ? 0 : meta; + } + }; + + template + class CompatTraits< ::std::char_traits > { + public: + typedef CompatTraits< ::std::string_char_traits > compatible_type; + }; + + // ** CompatAlloc gcc-2.95 specialisations --------------------------- + template<> + class CompatAlloc< ::std::alloc> + { + public: + typedef ::std::allocator compatible_type; + }; + + } // N.S. io +} // N.S. boost + + + + + +#endif // include guard + +#endif // if workaround Added: pkg/BH/inst/include/boost/format/detail/workarounds_stlport.hpp =================================================================== --- pkg/BH/inst/include/boost/format/detail/workarounds_stlport.hpp (rev 0) +++ pkg/BH/inst/include/boost/format/detail/workarounds_stlport.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,42 @@ +// ---------------------------------------------------------------------------- +// workarounds_stlport.hpp : workaround STLport issues +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. 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/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_MACROS_STLPORT_HPP +#define BOOST_MACROS_STLPORT_HPP + +#if defined(_STLPORT_VERSION) && BOOST_WORKAROUND( BOOST_MSVC, <= 1300) +// msvc-6-stlport fails to find basic_string::append( iterator, iterator) when linking +// might affect other MSwindows compilers +#define BOOST_NO_STRING_APPEND +#endif + +// *** This should go to "boost/config/stdlib/stlport.hpp". + +// If the streams are not native and there are problems with using templates +// accross namespaces, we define some macros to enable a workaround for this. + +// STLport 4.5 +#if !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) +# define BOOST_IO_STD +# define BOOST_IO_NEEDS_USING_DECLARATION +#endif + +// STLport 4.0 +#if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_OWN_NAMESPACE) && defined(BOOST_NO_USING_TEMPLATE) +# define BOOST_IO_STD +# define BOOST_IO_NEEDS_USING_DECLARATION +#endif + + +// ---------------------------------------------------------------------------- + +#endif // BOOST_MACROS_STLPORT_HPP Added: pkg/BH/inst/include/boost/fusion/adapted/std_pair.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/std_pair.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/std_pair.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,19 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STD_PAIR_HPP +#define BOOST_FUSION_ADAPTED_STD_PAIR_HPP + +#include +#include + +BOOST_FUSION_ADAPT_TPL_STRUCT( + (T1)(T2),(std::pair)(T1)(T2),(T1, first)(T2, second)) + +#endif Added: pkg/BH/inst/include/boost/fusion/include/std_pair.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/include/std_pair.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/include/std_pair.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,12 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_INCLUDE_STD_PAIR) +#define FUSION_INCLUDE_STD_PAIR + +#include + +#endif Added: pkg/BH/inst/include/boost/fusion/include/tuple.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/include/tuple.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/include/tuple.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,12 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_INCLUDE_TUPLE) +#define FUSION_INCLUDE_TUPLE + +#include + +#endif Added: pkg/BH/inst/include/boost/fusion/iterator/advance.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/iterator/advance.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/iterator/advance.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,92 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_ADVANCE_09172005_1146) +#define FUSION_ADVANCE_09172005_1146 + +#include +#include + +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + struct random_access_traversal_tag; + + // Special tags: + struct iterator_facade_tag; // iterator facade tag + struct boost_array_iterator_tag; // boost::array iterator tag + struct mpl_iterator_tag; // mpl sequence iterator tag + struct std_pair_iterator_tag; // std::pair iterator tag + + namespace extension + { + template + struct advance_impl + { + // default implementation + template + struct apply : + mpl::if_c< + (N::value > 0) + , advance_detail::forward + , advance_detail::backward + >::type + { + BOOST_MPL_ASSERT_NOT((traits::is_random_access)); + }; + }; + + template <> + struct advance_impl + { + template + struct apply : Iterator::template advance {}; + }; + + template <> + struct advance_impl; + + template <> + struct advance_impl; + + template <> + struct advance_impl; + } + + namespace result_of + { + template + struct advance_c + : extension::advance_impl::type>::template apply > + {}; + + template + struct advance + : extension::advance_impl::type>::template apply + {}; + } + + template + inline typename result_of::advance_c::type const + advance_c(Iterator const& i) + { + return result_of::advance_c::call(i); + } + + template + inline typename result_of::advance::type const + advance(Iterator const& i) + { + return result_of::advance::call(i); + } + +}} // namespace boost::fusion + +#endif Added: pkg/BH/inst/include/boost/fusion/iterator/basic_iterator.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/iterator/basic_iterator.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/iterator/basic_iterator.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,141 @@ +/*============================================================================= + Copyright (c) 2009 Christopher Schmidt + + Distributed under the 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_FUSION_ITERATOR_BASIC_ITERATOR_HPP +#define BOOST_FUSION_ITERATOR_BASIC_ITERATOR_HPP + +#include + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + namespace extension + { + template + struct value_of_impl; + + template + struct deref_impl; + + template + struct value_of_data_impl; + + template + struct key_of_impl; + + template + struct deref_data_impl; + } + + template + struct basic_iterator + : iterator_facade, Category> + { + typedef mpl::int_ index; + typedef Seq seq_type; + + template + struct value_of + : extension::value_of_impl::template apply + {}; + + template + struct deref + : extension::deref_impl::template apply + {}; + + template + struct value_of_data + : extension::value_of_data_impl::template apply + {}; + + template + struct key_of + : extension::key_of_impl::template apply + {}; + + template + struct deref_data + : extension::deref_data_impl::template apply + {}; + + template + struct advance + { + typedef + basic_iterator + type; + + static type + call(It const& it) + { + return type(*it.seq,0); + } + }; + + template + struct next + : advance > + {}; + + template + struct prior + : advance > + {}; + + template + struct distance + { + typedef mpl::minus type; + + static + type + call(It1 const&, It2 const&) + { + return type(); + } + }; + + template + struct equal_to + : mpl::and_< + is_same< + typename remove_const::type + , typename remove_const::type + > + , mpl::equal_to + > + {}; + + template + basic_iterator(basic_iterator const& it) + : seq(it.seq) + {} + + basic_iterator(Seq& in_seq, int) + : seq(&in_seq) + {} + + template + basic_iterator& + operator=(basic_iterator const& it) + { + seq=it.seq; + return *this; + } + + Seq* seq; + }; +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/iterator/deref.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/iterator/deref.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/iterator/deref.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,72 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_DEREF_05042005_1019) +#define FUSION_DEREF_05042005_1019 + +#include +#include + +namespace boost { namespace fusion +{ + // Special tags: + struct iterator_facade_tag; // iterator facade tag + struct boost_array_iterator_tag; // boost::array iterator tag + struct mpl_iterator_tag; // mpl sequence iterator tag + struct std_pair_iterator_tag; // std::pair iterator tag + + namespace extension + { + template + struct deref_impl + { + template + struct apply {}; + }; + + template <> + struct deref_impl + { + template + struct apply : Iterator::template deref {}; + }; + + template <> + struct deref_impl; + + template <> + struct deref_impl; + + template <> + struct deref_impl; + } + + namespace result_of + { + template + struct deref + : extension::deref_impl::type>:: + template apply + {}; + } + + template + typename result_of::deref::type + deref(Iterator const& i) + { + typedef result_of::deref deref_meta; + return deref_meta::call(i); + } + + template + typename result_of::deref::type + operator*(iterator_base const& i) + { + return fusion::deref(i.cast()); + } +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/iterator/deref_data.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/iterator/deref_data.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/iterator/deref_data.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,49 @@ +/*============================================================================= + Copyright (c) 2009 Christopher Schmidt + + Distributed under the 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_FUSION_ITERATOR_DEREF_DATA_HPP +#define BOOST_FUSION_ITERATOR_DEREF_DATA_HPP + +#include + +namespace boost { namespace fusion +{ + struct iterator_facade_tag; + + namespace extension + { + template + struct deref_data_impl; + + template <> + struct deref_data_impl + { + template + struct apply + : It::template deref_data + {}; + }; + } + + namespace result_of + { + template + struct deref_data + : extension::deref_data_impl::type>:: + template apply + {}; + } + + template + typename result_of::deref_data::type + deref_data(It const& it) + { + return result_of::deref_data::call(it); + } +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/iterator/distance.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/iterator/distance.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/iterator/distance.hpp 2013-05-04 00:57:24 UTC (rev 34) @@ -0,0 +1,78 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_DISTANCE_09172005_0721) +#define FUSION_DISTANCE_09172005_0721 + +#include +#include + +#include +#include +#include + +#include + +namespace boost { namespace fusion +{ + struct random_access_traversal_tag; + + // Special tags: [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 34 From noreply at r-forge.r-project.org Sat May 4 03:02:12 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:02:12 +0200 (CEST) Subject: [Boostheaders-commits] r35 - in pkg/BH/inst/include/boost/fusion: adapted/mpl adapted/struct algorithm/transformation container/generation container/list container/vector iterator/detail iterator/mpl sequence/comparison sequence/intrinsic sequence/io support/detail tuple/detail view/iterator_range view/joint_view view/single_view Message-ID: <20130504010212.8555518545F@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:02:11 +0200 (Sat, 04 May 2013) New Revision: 35 Added: pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/ pkg/BH/inst/include/boost/fusion/adapted/mpl/mpl_iterator.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/adapt_struct.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/ pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_back.hpp pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_front.hpp pkg/BH/inst/include/boost/fusion/container/generation/ignore.hpp pkg/BH/inst/include/boost/fusion/container/list/cons.hpp pkg/BH/inst/include/boost/fusion/container/list/cons_fwd.hpp pkg/BH/inst/include/boost/fusion/container/list/cons_iterator.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/ pkg/BH/inst/include/boost/fusion/container/list/limits.hpp pkg/BH/inst/include/boost/fusion/container/list/list_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/ pkg/BH/inst/include/boost/fusion/container/vector/limits.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector10.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector10_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector20.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector20_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector30.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector30_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector40.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector40_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector50.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector50_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/vector_iterator.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/adapt_deref_traits.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/adapt_value_traits.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/advance.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/distance.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/segment_sequence.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/segmented_equal_to.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/segmented_iterator.hpp pkg/BH/inst/include/boost/fusion/iterator/detail/segmented_next_impl.hpp pkg/BH/inst/include/boost/fusion/iterator/mpl/convert_iterator.hpp pkg/BH/inst/include/boost/fusion/iterator/mpl/fusion_iterator.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/ pkg/BH/inst/include/boost/fusion/sequence/comparison/enable_comparison.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/equal_to.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/greater.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/greater_equal.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/less.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/less_equal.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/not_equal_to.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/at.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/begin.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/detail/ pkg/BH/inst/include/boost/fusion/sequence/intrinsic/empty.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/end.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/segments.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/size.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/value_at.hpp pkg/BH/inst/include/boost/fusion/sequence/io/detail/ pkg/BH/inst/include/boost/fusion/sequence/io/in.hpp pkg/BH/inst/include/boost/fusion/sequence/io/out.hpp pkg/BH/inst/include/boost/fusion/support/detail/access.hpp pkg/BH/inst/include/boost/fusion/support/detail/as_fusion_element.hpp pkg/BH/inst/include/boost/fusion/support/detail/category_of.hpp pkg/BH/inst/include/boost/fusion/support/detail/is_mpl_sequence.hpp pkg/BH/inst/include/boost/fusion/support/detail/is_view.hpp pkg/BH/inst/include/boost/fusion/support/detail/mpl_iterator_category.hpp pkg/BH/inst/include/boost/fusion/support/detail/pp_round.hpp pkg/BH/inst/include/boost/fusion/support/detail/segmented_fold_until_impl.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/ pkg/BH/inst/include/boost/fusion/tuple/detail/tuple_expand.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/ pkg/BH/inst/include/boost/fusion/view/iterator_range/iterator_range.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/ pkg/BH/inst/include/boost/fusion/view/joint_view/joint_view.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/joint_view_fwd.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/joint_view_iterator.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/ pkg/BH/inst/include/boost/fusion/view/single_view/single_view.hpp pkg/BH/inst/include/boost/fusion/view/single_view/single_view_iterator.hpp Log: steps towards BH 1.51.0-1 with foreach and math distributions Added: pkg/BH/inst/include/boost/fusion/adapted/mpl/mpl_iterator.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/mpl/mpl_iterator.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/mpl/mpl_iterator.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,113 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_MPL_ITERATOR_05052005_0731) +#define FUSION_MPL_ITERATOR_05052005_0731 + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + template + struct mpl_iterator + : iterator_facade< + mpl_iterator + , typename detail::mpl_iterator_category::type + > + { + typedef typename remove_const::type iterator_type; + + template + struct value_of : mpl::deref {}; + + template + struct deref + { + typedef typename mpl::deref< + typename Iterator::iterator_type>::type + type; + + static type + call(Iterator) + { + return type(); + } + }; + + template + struct next + { + typedef mpl_iterator< + typename mpl::next::type> + type; + + static type + call(Iterator) + { + return type(); + } + }; + + template + struct prior + { + typedef mpl_iterator< + typename mpl::prior::type> + type; + + static type + call(Iterator) + { + return type(); + } + }; + + template + struct advance + { + typedef mpl_iterator< + typename mpl::advance::type> + type; + + static type + call(Iterator const& /*i*/) + { + return type(); + } + }; + + template + struct distance : + mpl::distance< + typename I1::iterator_type + , typename I2::iterator_type> + { + typedef typename + mpl::distance< + typename I1::iterator_type + , typename I2::iterator_type + >::type + type; + + static type + call(I1 const&, I2 const&) + { + return type(); + } + }; + }; +}} + +#endif + + Added: pkg/BH/inst/include/boost/fusion/adapted/struct/adapt_struct.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/adapt_struct.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/adapt_struct.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,71 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + Copyright (c) 2009-2011 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BOOST_FUSION_ADAPT_STRUCT_FILLER_0(X, Y) \ + ((X, Y)) BOOST_FUSION_ADAPT_STRUCT_FILLER_1 +#define BOOST_FUSION_ADAPT_STRUCT_FILLER_1(X, Y) \ + ((X, Y)) BOOST_FUSION_ADAPT_STRUCT_FILLER_0 +#define BOOST_FUSION_ADAPT_STRUCT_FILLER_0_END +#define BOOST_FUSION_ADAPT_STRUCT_FILLER_1_END + +#define BOOST_FUSION_ADAPT_STRUCT_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE)\ + BOOST_FUSION_ADAPT_STRUCT_C_BASE( \ + TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY,ATTRIBUTE,2) + +#define BOOST_FUSION_ADAPT_TPL_STRUCT(TEMPLATE_PARAMS_SEQ,NAME_SEQ, ATTRIBUTES) \ + BOOST_FUSION_ADAPT_STRUCT_BASE( \ + (1)TEMPLATE_PARAMS_SEQ, \ + (1)NAME_SEQ, \ + struct_tag, \ + 0, \ + ((0,0)) BOOST_PP_CAT( \ + BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END), \ + BOOST_FUSION_ADAPT_STRUCT_C) + +#define BOOST_FUSION_ADAPT_STRUCT(NAME, ATTRIBUTES) \ + BOOST_FUSION_ADAPT_STRUCT_BASE( \ + (0), \ + (0)(NAME), \ + struct_tag, \ + 0, \ + BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0(0,0)ATTRIBUTES,_END), \ + BOOST_FUSION_ADAPT_STRUCT_C) + +#define BOOST_FUSION_ADAPT_STRUCT_AS_VIEW(NAME, ATTRIBUTES) \ + BOOST_FUSION_ADAPT_STRUCT_BASE( \ + (0), \ + (0)(NAME), \ + struct_tag, \ + 1, \ + BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0(0,0)ATTRIBUTES,_END), \ + BOOST_FUSION_ADAPT_STRUCT_C) + +#endif Added: pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_back.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_back.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_back.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,46 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_PUSH_BACK_07162005_0235) +#define FUSION_PUSH_BACK_07162005_0235 + +#include +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + namespace result_of + { + template + struct push_back + { + typedef fusion::single_view::type> single_view; + typedef joint_view type; + }; + } + + template + inline + typename + lazy_enable_if< + traits::is_sequence + , result_of::push_back + >::type + push_back(Sequence const& seq, T const& x) + { + typedef typename result_of::push_back push_back; + typedef typename push_back::single_view single_view; + typedef typename push_back::type result; + single_view x_(x); + return result(seq, x_); + } +}} + +#endif + Added: pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_front.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_front.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/algorithm/transformation/push_front.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,46 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_PUSH_FRONT_07162005_0749) +#define FUSION_PUSH_FRONT_07162005_0749 + +#include +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + namespace result_of + { + template + struct push_front + { + typedef fusion::single_view::type> single_view; + typedef joint_view type; + }; + } + + template + inline + typename + lazy_enable_if< + traits::is_sequence + , result_of::push_front + >::type + push_front(Sequence const& seq, T const& x) + { + typedef typename result_of::push_front push_front; + typedef typename push_front::single_view single_view; + typedef typename push_front::type result; + single_view x_(x); + return result(x_, seq); + } +}} + +#endif + Added: pkg/BH/inst/include/boost/fusion/container/generation/ignore.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/generation/ignore.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/generation/ignore.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,32 @@ +/*============================================================================= + Copyright (c) 2001 Doug Gregor + Copyright (c) 1999-2003 Jaakko Jarvi + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_IGNORE_07192005_0329) +#define FUSION_IGNORE_07192005_0329 + +namespace boost { namespace fusion +{ + // Swallows any assignment (by Doug Gregor) + namespace detail + { + struct swallow_assign + { + template + swallow_assign const& + operator=(const T&) const + { + return *this; + } + }; + } + + // "ignore" allows tuple positions to be ignored when using "tie". + detail::swallow_assign const ignore = detail::swallow_assign(); +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/container/list/cons.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/cons.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/cons.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,144 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005 Eric Niebler + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_CONS_07172005_0843) +#define FUSION_CONS_07172005_0843 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + struct void_; + struct cons_tag; + struct forward_traversal_tag; + struct fusion_sequence_tag; + + struct nil : sequence_base + { + typedef mpl::int_<0> size; + typedef cons_tag fusion_tag; + typedef fusion_sequence_tag tag; // this gets picked up by MPL + typedef mpl::false_ is_view; + typedef forward_traversal_tag category; + typedef void_ car_type; + typedef void_ cdr_type; + + nil() {} + + template + nil(Iterator const& /*iter*/, mpl::true_ /*this_is_an_iterator*/) + {} + + template + void assign_from_iter(Iterator const& /*iter*/) + { + } + }; + + template + struct cons : sequence_base > + { + typedef mpl::int_ size; + typedef cons_tag fusion_tag; + typedef fusion_sequence_tag tag; // this gets picked up by MPL + typedef mpl::false_ is_view; + typedef forward_traversal_tag category; + typedef Car car_type; + typedef Cdr cdr_type; + + cons() + : car(), cdr() {} + + explicit cons(typename detail::call_param::type in_car) + : car(in_car), cdr() {} + + cons( + typename detail::call_param::type in_car + , typename detail::call_param::type in_cdr) + : car(in_car), cdr(in_cdr) {} + + template + cons(cons const& rhs) + : car(rhs.car), cdr(rhs.cdr) {} + + cons(cons const& rhs) + : car(rhs.car), cdr(rhs.cdr) {} + + template + cons( + Sequence const& seq + , typename boost::disable_if< + mpl::or_< + is_convertible // use copy ctor instead + , is_convertible // use copy to car instead + > + >::type* /*dummy*/ = 0 + ) + : car(*fusion::begin(seq)) + , cdr(fusion::next(fusion::begin(seq)), mpl::true_()) {} + + template + cons(Iterator const& iter, mpl::true_ /*this_is_an_iterator*/) + : car(*iter) + , cdr(fusion::next(iter), mpl::true_()) {} + + template + cons& operator=(cons const& rhs) + { + car = rhs.car; + cdr = rhs.cdr; + return *this; + } + + cons& operator=(cons const& rhs) + { + car = rhs.car; + cdr = rhs.cdr; + return *this; + } + + template + typename boost::disable_if, cons&>::type + operator=(Sequence const& seq) + { + typedef typename result_of::begin::type Iterator; + Iterator iter = fusion::begin(seq); + this->assign_from_iter(iter); + return *this; + } + + template + void assign_from_iter(Iterator const& iter) + { + car = *iter; + cdr.assign_from_iter(fusion::next(iter)); + } + + car_type car; + cdr_type cdr; + }; +}} + +#endif + Added: pkg/BH/inst/include/boost/fusion/container/list/cons_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/cons_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/cons_fwd.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,20 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005 Eric Niebler + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(BOOST_FUSION_CONS_FWD_HPP_INCLUDED) +#define BOOST_FUSION_CONS_FWD_HPP_INCLUDED + +namespace boost { namespace fusion +{ + struct nil; + + template + struct cons; +}} + +#endif + Added: pkg/BH/inst/include/boost/fusion/container/list/cons_iterator.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/cons_iterator.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/cons_iterator.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,89 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005 Eric Niebler + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_CONS_ITERATOR_07172005_0849) +#define FUSION_CONS_ITERATOR_07172005_0849 + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace fusion +{ + struct nil; + struct cons_iterator_tag; + struct forward_traversal_tag; + + template + struct cons_iterator_identity; + + template + struct cons_iterator : iterator_base > + { + typedef cons_iterator_tag fusion_tag; + typedef forward_traversal_tag category; + typedef Cons cons_type; + typedef cons_iterator_identity< + typename add_const::type> + identity; + + explicit cons_iterator(cons_type& in_cons) + : cons(in_cons) {} + + cons_type& cons; + + private: + // silence MSVC warning C4512: assignment operator could not be generated + cons_iterator& operator= (cons_iterator const&); + }; + + struct nil_iterator : iterator_base + { + typedef forward_traversal_tag category; + typedef cons_iterator_tag fusion_tag; + typedef nil cons_type; + typedef cons_iterator_identity< + add_const::type> + identity; + nil_iterator() {} + explicit nil_iterator(nil const&) {} + }; + + template <> + struct cons_iterator : nil_iterator + { + cons_iterator() {} + explicit cons_iterator(nil const&) {} + }; + + template <> + struct cons_iterator : nil_iterator + { + cons_iterator() {} + explicit cons_iterator(nil const&) {} + }; + + template <> + struct cons_iterator > : nil_iterator + { + cons_iterator() {} + explicit cons_iterator(nil const&) {} + }; + + template <> + struct cons_iterator const> : nil_iterator + { + cons_iterator() {} + explicit cons_iterator(nil const&) {} + }; +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/container/list/limits.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/limits.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/limits.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,21 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_LIST_LIMITS_07172005_0112) +#define FUSION_LIST_LIMITS_07172005_0112 + +#if !defined(FUSION_MAX_LIST_SIZE) +# define FUSION_MAX_LIST_SIZE 10 +#else +# if FUSION_MAX_LIST_SIZE < 3 +# undef FUSION_MAX_LIST_SIZE +# define FUSION_MAX_LIST_SIZE 10 +# endif +#endif + +#define FUSION_MAX_LIST_SIZE_STR BOOST_PP_STRINGIZE(BOOST_FUSION_PP_ROUND_UP(FUSION_MAX_LIST_SIZE)) + +#endif Added: pkg/BH/inst/include/boost/fusion/container/list/list_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/list_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/list_fwd.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,50 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_LIST_FORWARD_07172005_0224) +#define FUSION_LIST_FORWARD_07172005_0224 + +#include +#include + +#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES) +#include +#else +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/list" FUSION_MAX_LIST_SIZE_STR "_fwd.hpp") +#endif + +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ + +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 1) +#endif + +namespace boost { namespace fusion +{ + struct void_; + + template < + BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( + FUSION_MAX_LIST_SIZE, typename T, void_) + > + struct list; +}} + +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(output: null) +#endif + +#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES + +#endif Added: pkg/BH/inst/include/boost/fusion/container/vector/limits.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/vector/limits.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/vector/limits.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,23 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_VECTOR_LIMITS_07072005_1246) +#define FUSION_VECTOR_LIMITS_07072005_1246 + +#include + +#if !defined(FUSION_MAX_VECTOR_SIZE) +# define FUSION_MAX_VECTOR_SIZE 10 +#else +# if FUSION_MAX_VECTOR_SIZE < 3 +# undef FUSION_MAX_VECTOR_SIZE +# define FUSION_MAX_VECTOR_SIZE 10 +# endif +#endif + +#define FUSION_MAX_VECTOR_SIZE_STR BOOST_PP_STRINGIZE(BOOST_FUSION_PP_ROUND_UP(FUSION_MAX_VECTOR_SIZE)) + +#endif Added: pkg/BH/inst/include/boost/fusion/container/vector/vector.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/vector/vector.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/vector/vector.hpp 2013-05-04 01:02:11 UTC (rev 35) @@ -0,0 +1,191 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_VECTOR_07072005_1244) +#define FUSION_VECTOR_07072005_1244 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(__WAVE__) + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600) + +#define BOOST_FUSION_VECTOR_COPY_INIT() \ + ctor_helper(rhs, is_base_of()) \ + +#define BOOST_FUSION_VECTOR_CTOR_HELPER() \ + static vector_n const& \ + ctor_helper(vector const& rhs, mpl::true_) \ + { \ + return rhs.vec; \ + } \ + \ + template \ + static T const& \ + ctor_helper(T const& rhs, mpl::false_) \ + { \ + return rhs; \ + } + +#else + +#define BOOST_FUSION_VECTOR_COPY_INIT() \ + rhs \ + +#define BOOST_FUSION_VECTOR_CTOR_HELPER() + +#endif + +#endif // !defined(__WAVE__) + +#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES) +#include +#else +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/vvector" FUSION_MAX_VECTOR_SIZE_STR ".hpp") +#endif + +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ + +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 1) +#endif + +namespace boost { namespace fusion +{ + struct void_; + struct fusion_sequence_tag; + + template + struct vector + : sequence_base > + { + private: + + typedef typename detail::vector_n_chooser< + BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>::type + vector_n; + + template + friend struct vector; + + public: + + typedef typename vector_n::types types; + typedef typename vector_n::fusion_tag fusion_tag; + typedef typename vector_n::tag tag; + typedef typename vector_n::size size; + typedef typename vector_n::category category; + typedef typename vector_n::is_view is_view; + + vector() + : vec() {} + + template + vector(vector const& rhs) + : vec(rhs.vec) {} + + vector(vector const& rhs) + : vec(rhs.vec) {} + + template + vector(Sequence const& rhs) + : vec(BOOST_FUSION_VECTOR_COPY_INIT()) {} + + // Expand a couple of forwarding constructors for arguments + // of type (T0), (T0, T1), (T0, T1, T2) etc. Example: + // + // vector( + // typename detail::call_param::type _0 + // , typename detail::call_param::type _1) + // : vec(_0, _1) {} + #include + + template + vector& + operator=(vector const& rhs) + { + vec = rhs.vec; + return *this; + } + + template + vector& + operator=(T const& rhs) + { + vec = rhs; + return *this; + } + + template + typename add_reference< + typename mpl::at_c::type + >::type + at_impl(mpl::int_ index) + { + return vec.at_impl(index); + } + + template + typename add_reference< + typename add_const< + typename mpl::at_c::type + >::type + >::type + at_impl(mpl::int_ index) const + { + return vec.at_impl(index); + } + + template + typename add_reference< + typename mpl::at::type + >::type + at_impl(I /*index*/) + { + return vec.at_impl(mpl::int_()); + } + + template + typename add_reference< [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 35 From noreply at r-forge.r-project.org Sat May 4 03:03:04 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:03:04 +0200 (CEST) Subject: [Boostheaders-commits] r36 - in pkg/BH/inst/include/boost/fusion: adapted/mpl/detail adapted/struct/detail container/list/detail container/vector/detail sequence/comparison/detail sequence/intrinsic/detail sequence/io/detail tuple/detail/preprocessed view/iterator_range/detail view/joint_view/detail view/single_view/detail Message-ID: <20130504010304.37BB618545F@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:03:03 +0200 (Sat, 04 May 2013) New Revision: 36 Added: pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/adapt_base.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/at_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/category_of_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/deref_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/extension.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/is_view_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/size_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/value_at_impl.hpp pkg/BH/inst/include/boost/fusion/adapted/struct/detail/value_of_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/at_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/deref_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/empty_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/equal_to_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/next_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/ pkg/BH/inst/include/boost/fusion/container/list/detail/reverse_cons.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/value_at_impl.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/value_of_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/advance_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/at_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/deref_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/distance_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/equal_to_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/next_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/ pkg/BH/inst/include/boost/fusion/container/vector/detail/prior_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/value_at_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/value_of_impl.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/vector_forward_ctor.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/vector_n.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/vector_n_chooser.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/equal_to.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/greater.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/greater_equal.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/less.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/less_equal.hpp pkg/BH/inst/include/boost/fusion/sequence/comparison/detail/not_equal_to.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp pkg/BH/inst/include/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp pkg/BH/inst/include/boost/fusion/sequence/io/detail/in.hpp pkg/BH/inst/include/boost/fusion/sequence/io/detail/manip.hpp pkg/BH/inst/include/boost/fusion/sequence/io/detail/out.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/make_tuple.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/make_tuple10.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/make_tuple20.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/make_tuple30.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/make_tuple40.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/make_tuple50.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple10.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple10_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple20.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple20_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple30.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple30_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple40.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple40_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple50.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple50_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_fwd.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_tie.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_tie10.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_tie20.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_tie30.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_tie40.hpp pkg/BH/inst/include/boost/fusion/tuple/detail/preprocessed/tuple_tie50.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/at_impl.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/segments_impl.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/size_impl.hpp pkg/BH/inst/include/boost/fusion/view/iterator_range/detail/value_at_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/deref_data_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/deref_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/key_of_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/next_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/value_of_data_impl.hpp pkg/BH/inst/include/boost/fusion/view/joint_view/detail/value_of_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/advance_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/at_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/begin_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/deref_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/distance_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/end_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/equal_to_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/next_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/prior_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/size_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/value_at_impl.hpp pkg/BH/inst/include/boost/fusion/view/single_view/detail/value_of_impl.hpp Log: steps towards BH 1.51.0-1 with foreach and math distributions Added: pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/begin_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/begin_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/begin_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,45 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(BOOST_FUSION_BEGIN_IMPL_31122005_1209) +#define BOOST_FUSION_BEGIN_IMPL_31122005_1209 + +#include +#include +#include + +namespace boost { namespace fusion { + + struct mpl_sequence_tag; + + namespace extension + { + template + struct begin_impl; + + template <> + struct begin_impl + { + template + struct apply + { + typedef typename mpl::begin< + typename remove_const::type + >::type iterator; + typedef mpl_iterator type; + + static type + call(Sequence) + { + return type(); + } + }; + }; + } +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/end_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/end_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/mpl/detail/end_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,45 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(BOOST_FUSION_END_IMPL_31122005_1237) +#define BOOST_FUSION_END_IMPL_31122005_1237 + +#include +#include +#include + +namespace boost { namespace fusion +{ + struct mpl_sequence_tag; + + namespace extension + { + template + struct end_impl; + + template <> + struct end_impl + { + template + struct apply + { + typedef typename mpl::end< + typename remove_const::type + >::type iterator; + typedef mpl_iterator type; + + static type + call(Sequence) + { + return type(); + } + }; + }; + } +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/adapt_base.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/adapt_base.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/adapt_base.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,245 @@ +/*============================================================================= + Copyright (c) 2001-2009 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2011 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_HPP + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME_TEMPLATE_PARAMS(SEQ) \ + BOOST_PP_SEQ_HEAD(SEQ) \ + BOOST_PP_EMPTY() + +#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(SEQ) \ + BOOST_PP_IF( \ + BOOST_PP_SEQ_HEAD(SEQ), \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME_TEMPLATE_PARAMS, \ + BOOST_PP_SEQ_HEAD)(BOOST_PP_SEQ_TAIL(SEQ)) + +#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL_C(R, _, ELEM) \ + (typename ELEM) +#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL(SEQ) \ + BOOST_PP_SEQ_ENUM( \ + BOOST_PP_SEQ_FOR_EACH( \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL_C, \ + _, \ + BOOST_PP_SEQ_TAIL(SEQ))) +#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(SEQ) \ + BOOST_PP_IF( \ + BOOST_PP_SEQ_HEAD(SEQ), \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL, \ + BOOST_PP_TUPLE_EAT(1))(SEQ) + +#ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS +# define BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ + MODIFIER, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ + > \ + struct tag_of< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) MODIFIER \ + , void \ + > \ + { \ + typedef TAG type; \ + }; +#else +# define BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ + MODIFIER, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ + > \ + struct tag_of \ + { \ + typedef TAG type; \ + }; +#endif + +#define BOOST_FUSION_ADAPT_STRUCT_BASE_UNPACK_AND_CALL(R,DATA,I,ATTRIBUTE) \ + BOOST_PP_TUPLE_ELEM(3,0,DATA)( \ + BOOST_PP_TUPLE_ELEM(3,1,DATA), \ + BOOST_PP_TUPLE_ELEM(3,2,DATA), \ + I, \ + ATTRIBUTE) + +#ifdef BOOST_MSVC +# define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAM(R,_,ELEM) \ + typedef ELEM ELEM; +# define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS_IMPL(SEQ) \ + BOOST_PP_SEQ_FOR_EACH( \ + BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAM, \ + _, \ + BOOST_PP_SEQ_TAIL(SEQ)) +# define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(SEQ) \ + BOOST_PP_IF( \ + BOOST_PP_SEQ_HEAD(SEQ), \ + BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS_IMPL, \ + BOOST_PP_TUPLE_EAT(1))(SEQ) +#else +# define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(SEQ) +#endif + +#define BOOST_FUSION_ADAPT_STRUCT_C_BASE( \ + TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,ATTRIBUTE,ATTRIBUTE_TUPEL_SIZE) \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ + > \ + struct access::struct_member< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \ + , I \ + > \ + { \ + typedef \ + BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) \ + attribute_type; \ + BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS( \ + TEMPLATE_PARAMS_SEQ) \ + \ + typedef attribute_type type; \ + \ + template \ + struct apply \ + { \ + typedef typename \ + add_reference< \ + typename mpl::eval_if< \ + is_const \ + , add_const \ + , mpl::identity \ + >::type \ + >::type \ + type; \ + \ + static type \ + call(Seq& seq) \ + { \ + return seq.PREFIX() \ + BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE); \ + } \ + }; \ + }; \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ + > \ + struct struct_member_name< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \ + , I \ + > \ + { \ + typedef char const* type; \ + \ + static type \ + call() \ + { \ + return BOOST_PP_STRINGIZE( \ + BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)); \ + } \ + }; + +#define BOOST_FUSION_ADAPT_STRUCT_BASE( \ + TEMPLATE_PARAMS_SEQ, \ + NAME_SEQ, \ + TAG, \ + IS_VIEW, \ + ATTRIBUTES_SEQ, \ + ATTRIBUTES_CALLBACK) \ + \ +namespace boost \ +{ \ + namespace fusion \ + { \ + namespace traits \ + { \ + BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ + BOOST_PP_EMPTY(), TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ + BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ + const, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ + } \ + \ + namespace extension \ + { \ + BOOST_PP_IF( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ + BOOST_PP_SEQ_FOR_EACH_I_R, \ + BOOST_PP_TUPLE_EAT(4))( \ + 1, \ + BOOST_FUSION_ADAPT_STRUCT_BASE_UNPACK_AND_CALL, \ + (ATTRIBUTES_CALLBACK,TEMPLATE_PARAMS_SEQ,NAME_SEQ), \ + BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ)) \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ + TEMPLATE_PARAMS_SEQ) \ + > \ + struct struct_size \ + : mpl::int_ \ + {}; \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ + TEMPLATE_PARAMS_SEQ) \ + > \ + struct struct_is_view< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \ + > \ + : mpl::BOOST_PP_IF(IS_VIEW,true_,false_) \ + {}; \ + } \ + } \ + \ + namespace mpl \ + { \ + template \ + struct sequence_tag; \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ + TEMPLATE_PARAMS_SEQ) \ + > \ + struct sequence_tag \ + { \ + typedef fusion::fusion_sequence_tag type; \ + }; \ + \ + template< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ + TEMPLATE_PARAMS_SEQ) \ + > \ + struct sequence_tag< \ + BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const \ + > \ + { \ + typedef fusion::fusion_sequence_tag type; \ + }; \ + } \ +} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/at_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/at_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/at_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,38 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_AT_IMPL_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_AT_IMPL_HPP + +#include + +namespace boost { namespace fusion { namespace extension +{ + template + struct at_impl; + + template <> + struct at_impl + { + template + struct apply + : access::struct_member< + typename remove_const::type + , N::value + >::template apply + {}; + }; + + template <> + struct at_impl + : at_impl + {}; +}}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/begin_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/begin_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/begin_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,67 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_BEGIN_IMPL_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_BEGIN_IMPL_HPP + +#include + +namespace boost { namespace fusion { namespace extension +{ + template + struct begin_impl; + + template <> + struct begin_impl + { + template + struct apply + { + typedef + basic_iterator< + struct_iterator_tag + , random_access_traversal_tag + , Seq + , 0 + > + type; + + static type + call(Seq& seq) + { + return type(seq,0); + } + }; + }; + + template <> + struct begin_impl + { + template + struct apply + { + typedef + basic_iterator< + struct_iterator_tag + , assoc_struct_category + , Seq + , 0 + > + type; + + static type + call(Seq& seq) + { + return type(seq,0); + } + }; + }; +}}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/category_of_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/category_of_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/category_of_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,42 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_CATEGORY_OF_IMPL_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_CATEGORY_OF_IMPL_HPP + +namespace boost { namespace fusion +{ + namespace extension + { + template + struct category_of_impl; + + template<> + struct category_of_impl + { + template + struct apply + { + typedef random_access_traversal_tag type; + }; + }; + + template<> + struct category_of_impl + { + template + struct apply + { + typedef assoc_struct_category type; + }; + }; + } +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/deref_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/deref_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/deref_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,41 @@ +/*============================================================================= + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_IMPL_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_IMPL_HPP + +namespace boost { namespace fusion { namespace extension +{ + template + struct deref_impl; + + template <> + struct deref_impl + { + template + struct apply + { + typedef typename + access::struct_member< + typename remove_const::type + , It::index::value + >::template apply + impl; + + typedef typename impl::type type; + + static + type + call(It const& it) + { + return impl::call(*it.seq); + } + }; + }; +}}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/end_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/end_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/end_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,67 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP + +#include + +namespace boost { namespace fusion { namespace extension +{ + template + struct end_impl; + + template <> + struct end_impl + { + template + struct apply + { + typedef + basic_iterator< + struct_iterator_tag + , random_access_traversal_tag + , Seq + , struct_size::type>::value + > + type; + + static type + call(Seq& seq) + { + return type(seq,0); + } + }; + }; + + template <> + struct end_impl + { + template + struct apply + { + typedef + basic_iterator< + struct_iterator_tag + , assoc_struct_category + , Seq + , struct_size::type>::value + > + type; + + static type + call(Seq& seq) + { + return type(seq,0); + } + }; + }; +}}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/extension.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/extension.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/extension.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,57 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_EXTENSION_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_EXTENSION_HPP + +#include + +namespace boost { namespace fusion +{ + struct struct_tag; + struct struct_iterator_tag; + struct assoc_struct_tag; + struct fusion_sequence_tag; + + struct assoc_struct_category + : random_access_traversal_tag, associative_tag + {}; + + namespace extension + { + struct no_such_member; + + struct access + { + template + struct struct_member; + + template + struct adt_attribute_access; + }; + + template + struct adt_attribute_proxy; + + template + struct struct_member_name; + + template + struct struct_size; + + template + struct struct_is_view; + + template + struct struct_assoc_key; + + } +}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp 2013-05-04 01:03:03 UTC (rev 36) @@ -0,0 +1,35 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + Distributed under the 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_FUSION_ADAPTED_STRUCT_DETAIL_IS_SEQUENCE_IMPL_HPP +#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_SEQUENCE_IMPL_HPP + +#include + +namespace boost { namespace fusion { namespace extension +{ + template + struct is_sequence_impl; + + template<> + struct is_sequence_impl + { + template + struct apply + : mpl::true_ + {}; + }; + + template <> + struct is_sequence_impl + : is_sequence_impl + {}; +}}} + +#endif Added: pkg/BH/inst/include/boost/fusion/adapted/struct/detail/is_view_impl.hpp =================================================================== [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 36 From noreply at r-forge.r-project.org Sat May 4 03:03:49 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:03:49 +0200 (CEST) Subject: [Boostheaders-commits] r37 - in pkg/BH/inst/include/boost/fusion/container: list/detail/preprocessed vector/detail/preprocessed Message-ID: <20130504010350.0760918545F@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:03:48 +0200 (Sat, 04 May 2013) New Revision: 37 Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list10_fwd.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list20_fwd.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list30_fwd.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list40_fwd.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list50_fwd.hpp pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector10_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector20.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector20_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector30.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector30_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector40.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector40_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector50.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector50_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_chooser.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_chooser10.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_chooser20.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_chooser30.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_chooser40.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_chooser50.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector10.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector10_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector20.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector20_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector30.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector30_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector40.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector40_fwd.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector50.hpp pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vvector50_fwd.hpp Log: steps towards BH 1.51.0-1 with foreach and math distributions Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list10_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list10_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list10_fwd.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,16 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ +namespace boost { namespace fusion +{ + struct void_; + template < + typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ + > + struct list; +}} Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list20_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list20_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list20_fwd.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,16 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ +namespace boost { namespace fusion +{ + struct void_; + template < + typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ + > + struct list; +}} Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list30_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list30_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list30_fwd.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,16 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ +namespace boost { namespace fusion +{ + struct void_; + template < + typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = void_ + > + struct list; +}} Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list40_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list40_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list40_fwd.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,16 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ +namespace boost { namespace fusion +{ + struct void_; + template < + typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = void_ , typename T30 = void_ , typename T31 = void_ , typename T32 = void_ , typename T33 = void_ , typename T34 = void_ , typename T35 = void_ , typename T36 = void_ , typename T37 = void_ , typename T38 = void_ , typename T39 = void_ + > + struct list; +}} Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list50_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list50_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list50_fwd.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,16 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ +namespace boost { namespace fusion +{ + struct void_; + template < + typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = void_ , typename T30 = void_ , typename T31 = void_ , typename T32 = void_ , typename T33 = void_ , typename T34 = void_ , typename T35 = void_ , typename T36 = void_ , typename T37 = void_ , typename T38 = void_ , typename T39 = void_ , typename T40 = void_ , typename T41 = void_ , typename T42 = void_ , typename T43 = void_ , typename T44 = void_ , typename T45 = void_ , typename T46 = void_ , typename T47 = void_ , typename T48 = void_ , typename T49 = void_ + > + struct list; +}} Added: pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list_fwd.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list_fwd.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/list/detail/preprocessed/list_fwd.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,22 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ + +#if FUSION_MAX_LIST_SIZE <= 10 +#include +#elif FUSION_MAX_LIST_SIZE <= 20 +#include +#elif FUSION_MAX_LIST_SIZE <= 30 +#include +#elif FUSION_MAX_LIST_SIZE <= 40 +#include +#elif FUSION_MAX_LIST_SIZE <= 50 +#include +#else +#error "FUSION_MAX_LIST_SIZE out of bounds for preprocessed headers" +#endif Added: pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,22 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ + +#if FUSION_MAX_VECTOR_SIZE <= 10 +#include +#elif FUSION_MAX_VECTOR_SIZE <= 20 +#include +#elif FUSION_MAX_VECTOR_SIZE <= 30 +#include +#elif FUSION_MAX_VECTOR_SIZE <= 40 +#include +#elif FUSION_MAX_VECTOR_SIZE <= 50 +#include +#else +#error "FUSION_MAX_VECTOR_SIZE out of bounds for preprocessed headers" +#endif Added: pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp =================================================================== --- pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp (rev 0) +++ pkg/BH/inst/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp 2013-05-04 01:03:48 UTC (rev 37) @@ -0,0 +1,1004 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + Distributed under the 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 an auto-generated file. Do not edit! +==============================================================================*/ +namespace boost { namespace fusion +{ + template + struct vector_data1 + { + vector_data1() + : m0() {} + vector_data1( + typename detail::call_param::type _0) + : m0(_0) {} + vector_data1( + vector_data1 const& other) + : m0(other.m0) {} + vector_data1& + operator=(vector_data1 const& vec) + { + this->m0 = vec.m0; + return *this; + } + template + static vector_data1 + init_from_sequence(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + + return vector_data1(*i0); + } + template + static vector_data1 + init_from_sequence(Sequence& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + + return vector_data1(*i0); + } + T0 m0; + }; + template + struct vector1 + : vector_data1 + , sequence_base > + { + typedef vector1 this_type; + typedef vector_data1 base_type; + typedef mpl::vector1 types; + typedef vector_tag fusion_tag; + typedef fusion_sequence_tag tag; + typedef mpl::false_ is_view; + typedef random_access_traversal_tag category; + typedef mpl::int_<1> size; + vector1() {} + explicit + vector1( + typename detail::call_param::type _0) + : base_type(_0) {} + template + vector1( + vector1 const& vec) + : base_type(vec.m0) {} + template + vector1( + Sequence const& seq + , typename boost::disable_if >::type* = 0 + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector1( + Sequence& seq + , typename boost::disable_if >::type* = 0 + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector1& + operator=(vector1 const& vec) + { + this->m0 = vec.m0; + return *this; + } + template + typename boost::disable_if, this_type&>::type + operator=(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + + this->m0 = *i0; + return *this; + } + typename add_reference::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference::type>::type at_impl(mpl::int_<0>) const { return this->m0; } + template + typename add_reference::type>::type + at_impl(I) + { + return this->at_impl(mpl::int_()); + } + template + typename add_reference::type>::type>::type + at_impl(I) const + { + return this->at_impl(mpl::int_()); + } + }; + template + struct vector_data2 + { + vector_data2() + : m0() , m1() {} + vector_data2( + typename detail::call_param::type _0 , typename detail::call_param::type _1) + : m0(_0) , m1(_1) {} + vector_data2( + vector_data2 const& other) + : m0(other.m0) , m1(other.m1) {} + vector_data2& + operator=(vector_data2 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; + return *this; + } + template + static vector_data2 + init_from_sequence(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); + return vector_data2(*i0 , *i1); + } + template + static vector_data2 + init_from_sequence(Sequence& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); + return vector_data2(*i0 , *i1); + } + T0 m0; T1 m1; + }; + template + struct vector2 + : vector_data2 + , sequence_base > + { + typedef vector2 this_type; + typedef vector_data2 base_type; + typedef mpl::vector2 types; + typedef vector_tag fusion_tag; + typedef fusion_sequence_tag tag; + typedef mpl::false_ is_view; + typedef random_access_traversal_tag category; + typedef mpl::int_<2> size; + vector2() {} + vector2( + typename detail::call_param::type _0 , typename detail::call_param::type _1) + : base_type(_0 , _1) {} + template + vector2( + vector2 const& vec) + : base_type(vec.m0 , vec.m1) {} + template + vector2( + Sequence const& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector2( + Sequence& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector2& + operator=(vector2 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; + return *this; + } + template + typename boost::disable_if, this_type&>::type + operator=(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); + this->m0 = *i0; this->m1 = *i1; + return *this; + } + typename add_reference::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference::type>::type at_impl(mpl::int_<1>) const { return this->m1; } + template + typename add_reference::type>::type + at_impl(I) + { + return this->at_impl(mpl::int_()); + } + template + typename add_reference::type>::type>::type + at_impl(I) const + { + return this->at_impl(mpl::int_()); + } + }; + template + struct vector_data3 + { + vector_data3() + : m0() , m1() , m2() {} + vector_data3( + typename detail::call_param::type _0 , typename detail::call_param::type _1 , typename detail::call_param::type _2) + : m0(_0) , m1(_1) , m2(_2) {} + vector_data3( + vector_data3 const& other) + : m0(other.m0) , m1(other.m1) , m2(other.m2) {} + vector_data3& + operator=(vector_data3 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; + return *this; + } + template + static vector_data3 + init_from_sequence(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); + return vector_data3(*i0 , *i1 , *i2); + } + template + static vector_data3 + init_from_sequence(Sequence& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); + return vector_data3(*i0 , *i1 , *i2); + } + T0 m0; T1 m1; T2 m2; + }; + template + struct vector3 + : vector_data3 + , sequence_base > + { + typedef vector3 this_type; + typedef vector_data3 base_type; + typedef mpl::vector3 types; + typedef vector_tag fusion_tag; + typedef fusion_sequence_tag tag; + typedef mpl::false_ is_view; + typedef random_access_traversal_tag category; + typedef mpl::int_<3> size; + vector3() {} + vector3( + typename detail::call_param::type _0 , typename detail::call_param::type _1 , typename detail::call_param::type _2) + : base_type(_0 , _1 , _2) {} + template + vector3( + vector3 const& vec) + : base_type(vec.m0 , vec.m1 , vec.m2) {} + template + vector3( + Sequence const& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector3( + Sequence& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector3& + operator=(vector3 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; + return *this; + } + template + typename boost::disable_if, this_type&>::type + operator=(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); + this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; + return *this; + } + typename add_reference::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference::type>::type at_impl(mpl::int_<2>) const { return this->m2; } + template + typename add_reference::type>::type + at_impl(I) + { + return this->at_impl(mpl::int_()); + } + template + typename add_reference::type>::type>::type + at_impl(I) const + { + return this->at_impl(mpl::int_()); + } + }; + template + struct vector_data4 + { + vector_data4() + : m0() , m1() , m2() , m3() {} + vector_data4( + typename detail::call_param::type _0 , typename detail::call_param::type _1 , typename detail::call_param::type _2 , typename detail::call_param::type _3) + : m0(_0) , m1(_1) , m2(_2) , m3(_3) {} + vector_data4( + vector_data4 const& other) + : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) {} + vector_data4& + operator=(vector_data4 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; + return *this; + } + template + static vector_data4 + init_from_sequence(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); + return vector_data4(*i0 , *i1 , *i2 , *i3); + } + template + static vector_data4 + init_from_sequence(Sequence& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); + return vector_data4(*i0 , *i1 , *i2 , *i3); + } + T0 m0; T1 m1; T2 m2; T3 m3; + }; + template + struct vector4 + : vector_data4 + , sequence_base > + { + typedef vector4 this_type; + typedef vector_data4 base_type; + typedef mpl::vector4 types; + typedef vector_tag fusion_tag; + typedef fusion_sequence_tag tag; + typedef mpl::false_ is_view; + typedef random_access_traversal_tag category; + typedef mpl::int_<4> size; + vector4() {} + vector4( + typename detail::call_param::type _0 , typename detail::call_param::type _1 , typename detail::call_param::type _2 , typename detail::call_param::type _3) + : base_type(_0 , _1 , _2 , _3) {} + template + vector4( + vector4 const& vec) + : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3) {} + template + vector4( + Sequence const& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector4( + Sequence& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector4& + operator=(vector4 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; + return *this; + } + template + typename boost::disable_if, this_type&>::type + operator=(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); + this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; + return *this; + } + typename add_reference::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference::type>::type at_impl(mpl::int_<3>) const { return this->m3; } + template + typename add_reference::type>::type + at_impl(I) + { + return this->at_impl(mpl::int_()); + } + template + typename add_reference::type>::type>::type + at_impl(I) const + { + return this->at_impl(mpl::int_()); + } + }; + template + struct vector_data5 + { + vector_data5() + : m0() , m1() , m2() , m3() , m4() {} + vector_data5( + typename detail::call_param::type _0 , typename detail::call_param::type _1 , typename detail::call_param::type _2 , typename detail::call_param::type _3 , typename detail::call_param::type _4) + : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) {} + vector_data5( + vector_data5 const& other) + : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) {} + vector_data5& + operator=(vector_data5 const& vec) + { + this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; + return *this; + } + template + static vector_data5 + init_from_sequence(Sequence const& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); + return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4); + } + template + static vector_data5 + init_from_sequence(Sequence& seq) + { + typedef typename result_of::begin::type I0; + I0 i0 = fusion::begin(seq); + typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); + return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4); + } + T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; + }; + template + struct vector5 + : vector_data5 + , sequence_base > + { + typedef vector5 this_type; + typedef vector_data5 base_type; + typedef mpl::vector5 types; + typedef vector_tag fusion_tag; + typedef fusion_sequence_tag tag; + typedef mpl::false_ is_view; + typedef random_access_traversal_tag category; + typedef mpl::int_<5> size; + vector5() {} + vector5( + typename detail::call_param::type _0 , typename detail::call_param::type _1 , typename detail::call_param::type _2 , typename detail::call_param::type _3 , typename detail::call_param::type _4) + : base_type(_0 , _1 , _2 , _3 , _4) {} + template + vector5( + vector5 const& vec) + : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4) {} + template + vector5( + Sequence const& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector5( + Sequence& seq + ) + : base_type(base_type::init_from_sequence(seq)) {} + template + vector5& + operator=(vector5 const& vec) + { [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 37 From noreply at r-forge.r-project.org Sat May 4 03:04:42 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:04:42 +0200 (CEST) Subject: [Boostheaders-commits] r38 - in pkg/BH: . man Message-ID: <20130504010442.374B51854D0@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:04:41 +0200 (Sat, 04 May 2013) New Revision: 38 Modified: pkg/BH/DESCRIPTION pkg/BH/man/BH-package.Rd Log: release candidate 1.51.0-1 Modified: pkg/BH/DESCRIPTION =================================================================== --- pkg/BH/DESCRIPTION 2013-05-04 01:03:48 UTC (rev 37) +++ pkg/BH/DESCRIPTION 2013-05-04 01:04:41 UTC (rev 38) @@ -1,8 +1,8 @@ Package: BH Type: Package Title: The Boost C++ Libraries -Version: 1.51.0-0 -Date: 2013-01-29 +Version: 1.51.0-1 +Date: 2013-05-02 Author: John W. Emerson, Michael J. Kane, Dirk Eddelbuettel, JJ Allaire, and Romain Francois Maintainer: Jay Emerson Description: Boost provides free peer-reviewed portable C++ source Modified: pkg/BH/man/BH-package.Rd =================================================================== --- pkg/BH/man/BH-package.Rd 2013-05-04 01:03:48 UTC (rev 37) +++ pkg/BH/man/BH-package.Rd 2013-05-04 01:04:41 UTC (rev 38) @@ -14,8 +14,8 @@ \tabular{ll}{ Package: \tab BH\cr Type: \tab Package\cr -Version: \tab 1.51.0-0\cr -Date: \tab 2013-01-29\cr +Version: \tab 1.51.0-1\cr +Date: \tab 2013-05-02\cr License: \tab BSL-1.0\cr } Boost provides free peer-reviewed portable C++ source From noreply at r-forge.r-project.org Sat May 4 03:25:47 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:25:47 +0200 (CEST) Subject: [Boostheaders-commits] r39 - in pkg/BH/inst/include/boost: . algorithm algorithm/cxx11 algorithm/searching algorithm/searching/detail algorithm/string algorithm/string/detail algorithm/string/std exception exception/detail function function/detail iterator regex regex/config regex/pending regex/v4 test test/included tr1 tr1/tr1 Message-ID: <20130504012547.CFF19185164@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:25:45 +0200 (Sat, 04 May 2013) New Revision: 39 Added: pkg/BH/inst/include/boost/algorithm/clamp.hpp pkg/BH/inst/include/boost/algorithm/cxx11/ pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp pkg/BH/inst/include/boost/algorithm/cxx11/is_sorted.hpp pkg/BH/inst/include/boost/algorithm/cxx11/none_of.hpp pkg/BH/inst/include/boost/algorithm/cxx11/one_of.hpp pkg/BH/inst/include/boost/algorithm/cxx11/partition_copy.hpp pkg/BH/inst/include/boost/algorithm/cxx11/partition_point.hpp pkg/BH/inst/include/boost/algorithm/hex.hpp pkg/BH/inst/include/boost/algorithm/minmax.hpp pkg/BH/inst/include/boost/algorithm/minmax_element.hpp pkg/BH/inst/include/boost/algorithm/searching/ pkg/BH/inst/include/boost/algorithm/searching/boyer_moore.hpp pkg/BH/inst/include/boost/algorithm/searching/boyer_moore_horspool.hpp pkg/BH/inst/include/boost/algorithm/searching/detail/ pkg/BH/inst/include/boost/algorithm/searching/detail/bm_traits.hpp pkg/BH/inst/include/boost/algorithm/searching/detail/debugging.hpp pkg/BH/inst/include/boost/algorithm/searching/knuth_morris_pratt.hpp pkg/BH/inst/include/boost/algorithm/string.hpp pkg/BH/inst/include/boost/algorithm/string/case_conv.hpp pkg/BH/inst/include/boost/algorithm/string/classification.hpp pkg/BH/inst/include/boost/algorithm/string/detail/case_conv.hpp pkg/BH/inst/include/boost/algorithm/string/detail/classification.hpp pkg/BH/inst/include/boost/algorithm/string/detail/find_iterator.hpp pkg/BH/inst/include/boost/algorithm/string/detail/finder_regex.hpp pkg/BH/inst/include/boost/algorithm/string/detail/formatter_regex.hpp pkg/BH/inst/include/boost/algorithm/string/detail/predicate.hpp pkg/BH/inst/include/boost/algorithm/string/detail/trim.hpp pkg/BH/inst/include/boost/algorithm/string/erase.hpp pkg/BH/inst/include/boost/algorithm/string/find.hpp pkg/BH/inst/include/boost/algorithm/string/find_iterator.hpp pkg/BH/inst/include/boost/algorithm/string/iter_find.hpp pkg/BH/inst/include/boost/algorithm/string/join.hpp pkg/BH/inst/include/boost/algorithm/string/predicate.hpp pkg/BH/inst/include/boost/algorithm/string/predicate_facade.hpp pkg/BH/inst/include/boost/algorithm/string/regex.hpp pkg/BH/inst/include/boost/algorithm/string/regex_find_format.hpp pkg/BH/inst/include/boost/algorithm/string/split.hpp pkg/BH/inst/include/boost/algorithm/string/std/ pkg/BH/inst/include/boost/algorithm/string/std/list_traits.hpp pkg/BH/inst/include/boost/algorithm/string/std/rope_traits.hpp pkg/BH/inst/include/boost/algorithm/string/std/slist_traits.hpp pkg/BH/inst/include/boost/algorithm/string/std/string_traits.hpp pkg/BH/inst/include/boost/algorithm/string/std_containers_traits.hpp pkg/BH/inst/include/boost/algorithm/string/trim.hpp pkg/BH/inst/include/boost/algorithm/string/trim_all.hpp pkg/BH/inst/include/boost/algorithm/string_regex.hpp pkg/BH/inst/include/boost/cregex.hpp pkg/BH/inst/include/boost/exception/all.hpp pkg/BH/inst/include/boost/exception/detail/clone_current_exception.hpp pkg/BH/inst/include/boost/exception/detail/exception_ptr.hpp pkg/BH/inst/include/boost/exception/detail/is_output_streamable.hpp pkg/BH/inst/include/boost/exception/detail/object_hex_dump.hpp pkg/BH/inst/include/boost/exception/diagnostic_information.hpp pkg/BH/inst/include/boost/exception/errinfo_api_function.hpp pkg/BH/inst/include/boost/exception/errinfo_at_line.hpp pkg/BH/inst/include/boost/exception/errinfo_errno.hpp pkg/BH/inst/include/boost/exception/errinfo_file_handle.hpp pkg/BH/inst/include/boost/exception/errinfo_file_name.hpp pkg/BH/inst/include/boost/exception/errinfo_file_open_mode.hpp pkg/BH/inst/include/boost/exception/errinfo_nested_exception.hpp pkg/BH/inst/include/boost/exception/errinfo_type_info_name.hpp pkg/BH/inst/include/boost/exception/error_info.hpp pkg/BH/inst/include/boost/exception/info.hpp pkg/BH/inst/include/boost/exception/info_tuple.hpp pkg/BH/inst/include/boost/exception/to_string.hpp pkg/BH/inst/include/boost/exception/to_string_stub.hpp pkg/BH/inst/include/boost/exception_ptr.hpp pkg/BH/inst/include/boost/function.hpp pkg/BH/inst/include/boost/function/ pkg/BH/inst/include/boost/function/detail/ pkg/BH/inst/include/boost/function/detail/function_iterate.hpp pkg/BH/inst/include/boost/function/detail/gen_maybe_include.pl pkg/BH/inst/include/boost/function/detail/maybe_include.hpp pkg/BH/inst/include/boost/function/detail/prologue.hpp pkg/BH/inst/include/boost/function/function0.hpp pkg/BH/inst/include/boost/function/function1.hpp pkg/BH/inst/include/boost/function/function10.hpp pkg/BH/inst/include/boost/function/function2.hpp pkg/BH/inst/include/boost/function/function3.hpp pkg/BH/inst/include/boost/function/function4.hpp pkg/BH/inst/include/boost/function/function5.hpp pkg/BH/inst/include/boost/function/function6.hpp pkg/BH/inst/include/boost/function/function7.hpp pkg/BH/inst/include/boost/function/function8.hpp pkg/BH/inst/include/boost/function/function9.hpp pkg/BH/inst/include/boost/function/function_base.hpp pkg/BH/inst/include/boost/function/function_fwd.hpp pkg/BH/inst/include/boost/function/function_template.hpp pkg/BH/inst/include/boost/function_equal.hpp pkg/BH/inst/include/boost/iterator/transform_iterator.hpp pkg/BH/inst/include/boost/regex.hpp pkg/BH/inst/include/boost/regex/ pkg/BH/inst/include/boost/regex/config.hpp pkg/BH/inst/include/boost/regex/config/ pkg/BH/inst/include/boost/regex/config/borland.hpp pkg/BH/inst/include/boost/regex/config/cwchar.hpp pkg/BH/inst/include/boost/regex/icu.hpp pkg/BH/inst/include/boost/regex/pattern_except.hpp pkg/BH/inst/include/boost/regex/pending/ pkg/BH/inst/include/boost/regex/pending/object_cache.hpp pkg/BH/inst/include/boost/regex/pending/static_mutex.hpp pkg/BH/inst/include/boost/regex/pending/unicode_iterator.hpp pkg/BH/inst/include/boost/regex/regex_traits.hpp pkg/BH/inst/include/boost/regex/user.hpp pkg/BH/inst/include/boost/regex/v4/ pkg/BH/inst/include/boost/regex/v4/basic_regex.hpp pkg/BH/inst/include/boost/regex/v4/basic_regex_creator.hpp pkg/BH/inst/include/boost/regex/v4/basic_regex_parser.hpp pkg/BH/inst/include/boost/regex/v4/c_regex_traits.hpp pkg/BH/inst/include/boost/regex/v4/char_regex_traits.hpp pkg/BH/inst/include/boost/regex/v4/cpp_regex_traits.hpp pkg/BH/inst/include/boost/regex/v4/cregex.hpp pkg/BH/inst/include/boost/regex/v4/error_type.hpp pkg/BH/inst/include/boost/regex/v4/fileiter.hpp pkg/BH/inst/include/boost/regex/v4/instances.hpp pkg/BH/inst/include/boost/regex/v4/iterator_category.hpp pkg/BH/inst/include/boost/regex/v4/iterator_traits.hpp pkg/BH/inst/include/boost/regex/v4/match_flags.hpp pkg/BH/inst/include/boost/regex/v4/match_results.hpp pkg/BH/inst/include/boost/regex/v4/mem_block_cache.hpp pkg/BH/inst/include/boost/regex/v4/perl_matcher.hpp pkg/BH/inst/include/boost/regex/v4/perl_matcher_common.hpp pkg/BH/inst/include/boost/regex/v4/perl_matcher_non_recursive.hpp pkg/BH/inst/include/boost/regex/v4/perl_matcher_recursive.hpp pkg/BH/inst/include/boost/regex/v4/primary_transform.hpp pkg/BH/inst/include/boost/regex/v4/protected_call.hpp pkg/BH/inst/include/boost/regex/v4/regbase.hpp pkg/BH/inst/include/boost/regex/v4/regex.hpp pkg/BH/inst/include/boost/regex/v4/regex_format.hpp pkg/BH/inst/include/boost/regex/v4/regex_fwd.hpp pkg/BH/inst/include/boost/regex/v4/regex_grep.hpp pkg/BH/inst/include/boost/regex/v4/regex_iterator.hpp pkg/BH/inst/include/boost/regex/v4/regex_match.hpp pkg/BH/inst/include/boost/regex/v4/regex_merge.hpp pkg/BH/inst/include/boost/regex/v4/regex_raw_buffer.hpp pkg/BH/inst/include/boost/regex/v4/regex_replace.hpp pkg/BH/inst/include/boost/regex/v4/regex_search.hpp pkg/BH/inst/include/boost/regex/v4/regex_split.hpp pkg/BH/inst/include/boost/regex/v4/regex_token_iterator.hpp pkg/BH/inst/include/boost/regex/v4/regex_traits.hpp pkg/BH/inst/include/boost/regex/v4/regex_traits_defaults.hpp pkg/BH/inst/include/boost/regex/v4/regex_workaround.hpp pkg/BH/inst/include/boost/regex/v4/states.hpp pkg/BH/inst/include/boost/regex/v4/sub_match.hpp pkg/BH/inst/include/boost/regex/v4/syntax_type.hpp pkg/BH/inst/include/boost/regex/v4/u32regex_iterator.hpp pkg/BH/inst/include/boost/regex/v4/u32regex_token_iterator.hpp pkg/BH/inst/include/boost/regex/v4/w32_regex_traits.hpp pkg/BH/inst/include/boost/regex_fwd.hpp pkg/BH/inst/include/boost/test/included/test_exec_monitor.hpp pkg/BH/inst/include/boost/test/test_exec_monitor.hpp pkg/BH/inst/include/boost/tr1/tr1/ pkg/BH/inst/include/boost/tr1/tr1/tuple pkg/BH/inst/include/boost/tr1/tr1/unordered_map Log: also adding boost algorithms/ (in order to build ExactNumCI) Added: pkg/BH/inst/include/boost/algorithm/clamp.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/clamp.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/clamp.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,175 @@ +/* + Copyright (c) Marshall Clow 2008-2012. + + Distributed under the 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: + 27 June 2009 mtc First version + 23 Oct 2010 mtc Added predicate version + +*/ + +/// \file clamp.hpp +/// \brief Clamp algorithm +/// \author Marshall Clow +/// +/// Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215 + +#ifndef BOOST_ALGORITHM_CLAMP_HPP +#define BOOST_ALGORITHM_CLAMP_HPP + +#include // For std::less +#include // For std::iterator_traits +#include + +#include +#include +#include // for identity +#include // for boost::disable_if + +namespace boost { namespace algorithm { + +/// \fn clamp ( T const& val, +/// typename boost::mpl::identity::type const& lo, +/// typename boost::mpl::identity::type const& hi, Pred p ) +/// \return the value "val" brought into the range [ lo, hi ] +/// using the comparison predicate p. +/// If p ( val, lo ) return lo. +/// If p ( hi, val ) return hi. +/// Otherwise, return the original value. +/// +/// \param val The value to be clamped +/// \param lo The lower bound of the range to be clamped to +/// \param hi The upper bound of the range to be clamped to +/// \param p A predicate to use to compare the values. +/// p ( a, b ) returns a boolean. +/// + template + T const & clamp ( T const& val, + typename boost::mpl::identity::type const & lo, + typename boost::mpl::identity::type const & hi, Pred p ) + { +// assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they might be equal + return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val; + } + + +/// \fn clamp ( T const& val, +/// typename boost::mpl::identity::type const& lo, +/// typename boost::mpl::identity::type const& hi ) +/// \return the value "val" brought into the range [ lo, hi ]. +/// If the value is less than lo, return lo. +/// If the value is greater than "hi", return hi. +/// Otherwise, return the original value. +/// +/// \param val The value to be clamped +/// \param lo The lower bound of the range to be clamped to +/// \param hi The upper bound of the range to be clamped to +/// + template + T const& clamp ( const T& val, + typename boost::mpl::identity::type const & lo, + typename boost::mpl::identity::type const & hi ) + { + return (clamp) ( val, lo, hi, std::less()); + } + +/// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, +/// std::iterator_traits::value_type lo, +/// std::iterator_traits::value_type hi ) +/// \return clamp the sequence of values [first, last) into [ lo, hi ] +/// +/// \param first The start of the range of values +/// \param last One past the end of the range of input values +/// \param out An output iterator to write the clamped values into +/// \param lo The lower bound of the range to be clamped to +/// \param hi The upper bound of the range to be clamped to +/// + template + OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out, + typename std::iterator_traits::value_type lo, + typename std::iterator_traits::value_type hi ) + { + // this could also be written with bind and std::transform + while ( first != last ) + *out++ = clamp ( *first++, lo, hi ); + return out; + } + +/// \fn clamp_range ( const Range &r, OutputIterator out, +/// typename std::iterator_traits::type>::value_type lo, +/// typename std::iterator_traits::type>::value_type hi ) +/// \return clamp the sequence of values [first, last) into [ lo, hi ] +/// +/// \param r The range of values to be clamped +/// \param out An output iterator to write the clamped values into +/// \param lo The lower bound of the range to be clamped to +/// \param hi The upper bound of the range to be clamped to +/// + template + typename boost::disable_if_c::value, OutputIterator>::type + clamp_range ( const Range &r, OutputIterator out, + typename std::iterator_traits::type>::value_type lo, + typename std::iterator_traits::type>::value_type hi ) + { + return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi ); + } + + +/// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, +/// std::iterator_traits::value_type lo, +/// std::iterator_traits::value_type hi, Pred p ) +/// \return clamp the sequence of values [first, last) into [ lo, hi ] +/// using the comparison predicate p. +/// +/// \param first The start of the range of values +/// \param last One past the end of the range of input values +/// \param out An output iterator to write the clamped values into +/// \param lo The lower bound of the range to be clamped to +/// \param hi The upper bound of the range to be clamped to +/// \param p A predicate to use to compare the values. +/// p ( a, b ) returns a boolean. + +/// + template + OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out, + typename std::iterator_traits::value_type lo, + typename std::iterator_traits::value_type hi, Pred p ) + { + // this could also be written with bind and std::transform + while ( first != last ) + *out++ = clamp ( *first++, lo, hi, p ); + return out; + } + +/// \fn clamp_range ( const Range &r, OutputIterator out, +/// typename std::iterator_traits::type>::value_type lo, +/// typename std::iterator_traits::type>::value_type hi, +/// Pred p ) +/// \return clamp the sequence of values [first, last) into [ lo, hi ] +/// using the comparison predicate p. +/// +/// \param r The range of values to be clamped +/// \param out An output iterator to write the clamped values into +/// \param lo The lower bound of the range to be clamped to +/// \param hi The upper bound of the range to be clamped to +/// \param p A predicate to use to compare the values. +/// p ( a, b ) returns a boolean. +// +// Disable this template if the first two parameters are the same type; +// In that case, the user will get the two iterator version. + template + typename boost::disable_if_c::value, OutputIterator>::type + clamp_range ( const Range &r, OutputIterator out, + typename std::iterator_traits::type>::value_type lo, + typename std::iterator_traits::type>::value_type hi, + Pred p ) + { + return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p ); + } + + +}} + +#endif // BOOST_ALGORITHM_CLAMP_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,91 @@ +/* + Copyright (c) Marshall Clow 2008-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file all_of.hpp +/// \brief Test ranges to see if all elements match a value or predicate. +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_ALL_OF_HPP +#define BOOST_ALGORITHM_ALL_OF_HPP + +#include // for std::all_of, if available +#include +#include + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of all_of if it is available +using std::all_of; // Section 25.2.1 +#else +/// \fn all_of ( InputIterator first, InputIterator last, Predicate p ) +/// \return true if all elements in [first, last) satisfy the predicate 'p' +/// \note returns true on an empty range +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param p A predicate for testing the elements of the sequence +/// +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template +bool all_of ( InputIterator first, InputIterator last, Predicate p ) +{ + for ( ; first != last; ++first ) + if ( !p(*first)) + return false; + return true; +} +#endif + +/// \fn all_of ( const Range &r, Predicate p ) +/// \return true if all elements in the range satisfy the predicate 'p' +/// \note returns true on an empty range +/// +/// \param r The input range +/// \param p A predicate for testing the elements of the range +/// +template +bool all_of ( const Range &r, Predicate p ) +{ + return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p ); +} + +/// \fn all_of_equal ( InputIterator first, InputIterator last, const T &val ) +/// \return true if all elements in [first, last) are equal to 'val' +/// \note returns true on an empty range +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param val A value to compare against +/// +template +bool all_of_equal ( InputIterator first, InputIterator last, const T &val ) +{ + for ( ; first != last; ++first ) + if ( val != *first ) + return false; + return true; +} + +/// \fn all_of_equal ( const Range &r, const T &val ) +/// \return true if all elements in the range are equal to 'val' +/// \note returns true on an empty range +/// +/// \param r The input range +/// \param val A value to compare against +/// +template +bool all_of_equal ( const Range &r, const T &val ) +{ + return boost::algorithm::all_of_equal ( boost::begin (r), boost::end (r), val ); +} + +}} // namespace boost and algorithm + +#endif // BOOST_ALGORITHM_ALL_OF_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,90 @@ +/* + Copyright (c) Marshall Clow 2008-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + For more information, see http://www.boost.org +*/ + +/// \file +/// \brief Test ranges to see if any elements match a value or predicate. +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_ANY_OF_HPP +#define BOOST_ALGORITHM_ANY_OF_HPP + +#include // for std::any_of, if available +#include +#include + +namespace boost { namespace algorithm { + +// Use the C++11 versions of any_of if it is available +#if __cplusplus >= 201103L +using std::any_of; // Section 25.2.2 +#else +/// \fn any_of ( InputIterator first, InputIterator last, Predicate p ) +/// \return true if any of the elements in [first, last) satisfy the predicate +/// \note returns false on an empty range +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param p A predicate for testing the elements of the sequence +/// +template +bool any_of ( InputIterator first, InputIterator last, Predicate p ) +{ + for ( ; first != last; ++first ) + if ( p(*first)) + return true; + return false; +} +#endif + +/// \fn any_of ( const Range &r, Predicate p ) +/// \return true if any elements in the range satisfy the predicate 'p' +/// \note returns false on an empty range +/// +/// \param r The input range +/// \param p A predicate for testing the elements of the range +/// +template +bool any_of ( const Range &r, Predicate p ) +{ + return boost::algorithm::any_of (boost::begin (r), boost::end (r), p); +} + +/// \fn any_of_equal ( InputIterator first, InputIterator last, const V &val ) +/// \return true if any of the elements in [first, last) are equal to 'val' +/// \note returns false on an empty range +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param val A value to compare against +/// +template +bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) +{ + for ( ; first != last; ++first ) + if ( val == *first ) + return true; + return false; +} + +/// \fn any_of_equal ( const Range &r, const V &val ) +/// \return true if any of the elements in the range are equal to 'val' +/// \note returns false on an empty range +/// +/// \param r The input range +/// \param val A value to compare against +/// +template +bool any_of_equal ( const Range &r, const V &val ) +{ + return boost::algorithm::any_of_equal (boost::begin (r), boost::end (r), val); +} + +}} // namespace boost and algorithm + +#endif // BOOST_ALGORITHM_ANY_OF_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,133 @@ +/* + Copyright (c) Marshall Clow 2008-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file copy_if.hpp +/// \brief Copy a subset of a sequence to a new sequence +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_COPY_IF_HPP +#define BOOST_ALGORITHM_COPY_IF_HPP + +#include // for std::copy_if, if available +#include +#include + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of copy_if if it is available +using std::copy_if; // Section 25.3.1 +#else +/// \fn copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) +/// \brief Copies all the elements from the input range that satisfy the +/// predicate to the output range. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param result An output iterator to write the results into +/// \param p A predicate for testing the elements of the range +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template +OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) +{ + for ( ; first != last; ++first ) + if (p(*first)) + *result++ = first; + return result; +} +#endif + +/// \fn copy_if ( const Range &r, OutputIterator result, Predicate p ) +/// \brief Copies all the elements from the input range that satisfy the +/// predicate to the output range. +/// \return The updated output iterator +/// +/// \param r The input range +/// \param result An output iterator to write the results into +/// \param p A predicate for testing the elements of the range +/// +template +OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p ) +{ + return boost::algorithm::copy_if (boost::begin (r), boost::end(r), result, p); +} + + +/// \fn copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) +/// \brief Copies all the elements at the start of the input range that +/// satisfy the predicate to the output range. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param result An output iterator to write the results into +/// \param p A predicate for testing the elements of the range +/// +template +OutputIterator copy_while ( InputIterator first, InputIterator last, + OutputIterator result, Predicate p ) +{ + for ( ; first != last && p(*first); ++first ) + *result++ = first; + return result; +} + +/// \fn copy_while ( const Range &r, OutputIterator result, Predicate p ) +/// \brief Copies all the elements at the start of the input range that +/// satisfy the predicate to the output range. +/// \return The updated output iterator +/// +/// \param r The input range +/// \param result An output iterator to write the results into +/// \param p A predicate for testing the elements of the range +/// +template +OutputIterator copy_while ( const Range &r, OutputIterator result, Predicate p ) +{ + return boost::algorithm::copy_while (boost::begin (r), boost::end(r), result, p); +} + + +/// \fn copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) +/// \brief Copies all the elements at the start of the input range that do not +/// satisfy the predicate to the output range. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param result An output iterator to write the results into +/// \param p A predicate for testing the elements of the range +/// +template +OutputIterator copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) +{ + for ( ; first != last && !p(*first); ++first ) + *result++ = first; + return result; +} + +/// \fn copy_until ( const Range &r, OutputIterator result, Predicate p ) +/// \brief Copies all the elements at the start of the input range that do not +/// satisfy the predicate to the output range. +/// \return The updated output iterator +/// +/// \param r The input range +/// \param result An output iterator to write the results into +/// \param p A predicate for testing the elements of the range +/// +template +OutputIterator copy_until ( const Range &r, OutputIterator result, Predicate p ) +{ + return boost::algorithm::copy_until (boost::begin (r), boost::end(r), result, p); +} + +}} // namespace boost and algorithm + +#endif // BOOST_ALGORITHM_COPY_IF_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,44 @@ +/* + Copyright (c) Marshall Clow 2011-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file copy_n.hpp +/// \brief Copy n items from one sequence to another +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_COPY_N_HPP +#define BOOST_ALGORITHM_COPY_N_HPP + +#include // for std::copy_n, if available + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of copy_n if it is available +using std::copy_n; // Section 25.3.1 +#else +/// \fn copy_n ( InputIterator first, Size n, OutputIterator result ) +/// \brief Copies exactly n (n > 0) elements from the range starting at first to +/// the range starting at result. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param n The number of elements to copy +/// \param result An output iterator to write the results into +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template +OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result ) +{ + for ( ; n > 0; --n, ++first, ++result ) + *result = *first; + return result; +} +#endif +}} // namespace boost and algorithm + +#endif // BOOST_ALGORITHM_COPY_IF_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,60 @@ +/* + Copyright (c) Marshall Clow 2011-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file find_if_not.hpp +/// \brief Find the first element in a sequence that does not satisfy a predicate. +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP +#define BOOST_ALGORITHM_FIND_IF_NOT_HPP + +#include // for std::find_if_not, if it exists + +#include +#include + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of find_if_not if it is available +using std::find_if_not; // Section 25.2.5 +#else +/// \fn find_if_not(InputIterator first, InputIterator last, Predicate p) +/// \brief Finds the first element in the sequence that does not satisfy the predicate. +/// \return The iterator pointing to the desired element. +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param p A predicate for testing the elements of the range +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template +InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p ) +{ + for ( ; first != last; ++first ) + if ( !p(*first)) + break; + return first; +} +#endif + +/// \fn find_if_not ( const Range &r, Predicate p ) +/// \brief Finds the first element in the sequence that does not satisfy the predicate. +/// \return The iterator pointing to the desired element. +/// +/// \param r The input range +/// \param p A predicate for testing the elements of the range +/// +template +typename boost::range_iterator::type find_if_not ( const Range &r, Predicate p ) +{ + return boost::algorithm::find_if_not (boost::begin (r), boost::end(r), p); +} + +}} +#endif // BOOST_ALGORITHM_FIND_IF_NOT_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,74 @@ +/* + Copyright (c) Marshall Clow 2008-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file iota.hpp +/// \brief Generate an increasing series +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_IOTA_HPP +#define BOOST_ALGORITHM_IOTA_HPP + +#include + +#include +#include + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of iota if it is available +using std::iota; // Section 26.7.6 +#else +/// \fn iota ( ForwardIterator first, ForwardIterator last, T value ) +/// \brief Generates an increasing sequence of values, and stores them in [first, last) +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param value The initial value of the sequence to be generated +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template +void iota ( ForwardIterator first, ForwardIterator last, T value ) +{ + for ( ; first != last; ++first, ++value ) + *first = value; +} +#endif + +/// \fn iota ( Range &r, T value ) +/// \brief Generates an increasing sequence of values, and stores them in the input Range. +/// +/// \param r The input range +/// \param value The initial value of the sequence to be generated +/// +template +void iota ( Range &r, T value ) +{ + boost::algorithm::iota (boost::begin(r), boost::end(r), value); +} + + +/// \fn iota_n ( OutputIterator out, T value, std::size_t n ) +/// \brief Generates an increasing sequence of values, and stores them in the input Range. +/// +/// \param out An output iterator to write the results into +/// \param value The initial value of the sequence to be generated +/// \param n The number of items to write +/// +template +OutputIterator iota_n ( OutputIterator out, T value, std::size_t n ) +{ + while ( n-- > 0 ) + *out++ = value++; + + return out; +} + +}} + +#endif // BOOST_ALGORITHM_IOTA_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,65 @@ +/* + Copyright (c) Marshall Clow 2011-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file is_partitioned.hpp +/// \brief Tell if a sequence is partitioned +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP +#define BOOST_ALGORITHM_IS_PARTITIONED_HPP + +#include // for std::is_partitioned, if available + +#include +#include + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of is_partitioned if it is available +using std::is_partitioned; // Section 25.3.13 +#else +/// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p ) +/// \brief Tests to see if a sequence is partititioned according to a predicate +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param p The predicicate to test the values with +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template +bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p ) +{ +// Run through the part that satisfy the predicate + for ( ; first != last; ++first ) + if ( !p (*first)) + break; +// Now the part that does not satisfy the predicate + for ( ; first != last; ++first ) + if ( p (*first)) + return false; + return true; +} +#endif + +/// \fn is_partitioned ( const Range &r, UnaryPredicate p ) +/// \brief Generates an increasing sequence of values, and stores them in the input Range. +/// +/// \param r The input range +/// \param p The predicicate to test the values with +/// +template +bool is_partitioned ( const Range &r, UnaryPredicate p ) +{ + return boost::algorithm::is_partitioned (boost::begin(r), boost::end(r), p); +} + + +}} + +#endif // BOOST_ALGORITHM_IS_PARTITIONED_HPP Added: pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp =================================================================== --- pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp (rev 0) +++ pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp 2013-05-04 01:25:45 UTC (rev 39) @@ -0,0 +1,139 @@ +/* + Copyright (c) Marshall Clow 2011-2012. + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +/// \file is_permutation.hpp +/// \brief Is a sequence a permutation of another sequence +/// \author Marshall Clow + +#ifndef BOOST_ALGORITHM_IS_PERMUTATION_HPP +#define BOOST_ALGORITHM_IS_PERMUTATION_HPP + +#include // for std::less, tie, mismatch and is_permutation (if available) +#include // for std::make_pair +#include // for std::equal_to +#include + +#include +#include +#include +#include +#include // for tie + +namespace boost { namespace algorithm { + +#if __cplusplus >= 201103L +// Use the C++11 versions of is_permutation if it is available +using std::is_permutation; // Section 25.2.12 +#else +/// \cond DOXYGEN_HIDE +namespace detail { + template + struct value_predicate { + value_predicate ( Predicate p, Iterator it ) : p_ ( p ), it_ ( it ) {} + + template + bool operator () ( const T1 &t1 ) const { return p_ ( *it_, t1 ); } + private: + Predicate &p_; + Iterator it_; + }; +} +/// \endcond + + +/// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, BinaryPredicate p ) +/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2 +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param first2 The start of the second sequence +/// \param p The predicate to compare elements with +/// +/// \note This function is part of the C++2011 standard library. +/// We will use the standard one if it is available, +/// otherwise we have our own implementation. +template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate > +bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, BinaryPredicate p ) +{ +// Skip the common prefix (if any) +// std::tie (first1, first2) = std::mismatch (first1, last1, first2, p); + std::pair eq = std::mismatch (first1, last1, first2, p); + first1 = eq.first; + first2 = eq.second; + if ( first1 != last1 ) { + // Create last2 + ForwardIterator2 last2 = first2; + std::advance ( last2, std::distance (first1, last1)); + + // for each unique value in the sequence [first1,last1), count how many times + // it occurs, and make sure it occurs the same number of times in [first2, last2) + for ( ForwardIterator1 iter = first1; iter != last1; ++iter ) { [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 39 From noreply at r-forge.r-project.org Sat May 4 03:26:40 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:26:40 +0200 (CEST) Subject: [Boostheaders-commits] r40 - / Message-ID: <20130504012640.53F20185164@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:26:39 +0200 (Sat, 04 May 2013) New Revision: 40 Modified: CreateBoost.sh Log: also scan for 'algorithm' library (needed by ExactNumCI) Modified: CreateBoost.sh =================================================================== --- CreateBoost.sh 2013-05-04 01:25:45 UTC (rev 39) +++ CreateBoost.sh 2013-05-04 01:26:39 UTC (rev 40) @@ -28,7 +28,7 @@ ## A sanity check here before continuing: if [ ! -f ${boostall} ] && [ ! -d ${boostroot} ]; then echo "The Boost input file or directory do not exist. Exiting." - exit -1 + exit 1 fi ## DE: Needed? Can we not just overwrite? @@ -43,7 +43,7 @@ for prog in ${progs}; do if [ ! -x /usr/bin/${prog} ] && [ ! -x /usr/local/bin/${prog} ]; then echo "** Program '${prog}' not found, exiting" - exit -1 + exit 1 fi done @@ -51,7 +51,7 @@ for dir in ${sources}; do if [ ! -d ${dir} ]; then echo "** Source directory ${dir} not found, exiting" - exit -1 + exit 1 fi done @@ -83,8 +83,9 @@ # Plus foreach (cf issue ticket #2527) bcp --boost=${boostroot} foreach ${pkgdir}/inst/include >> bcp.log -# Plus math/distributions (cf issue ticket #2533) +# Plus math/distributions + algorithm (cf issue ticket #2533) bcp --boost=${boostroot} math/distributions ${pkgdir}/inst/include >> bcp.log +bcp --boost=${boostroot} algorithm ${pkgdir}/inst/include >> bcp.log # Plus iostream (cf issue ticket #2768) -- thia is a null-op, why? bcp --boost=${boostroot} iostream ${pkgdir}/inst/include >> bcp.log From noreply at r-forge.r-project.org Sat May 4 03:45:39 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:45:39 +0200 (CEST) Subject: [Boostheaders-commits] r41 - in pkg/BH/inst/include/boost: . detail iostreams iostreams/detail iostreams/detail/adapter iostreams/detail/broken_overload_resolution iostreams/detail/config iostreams/detail/streambuf iostreams/detail/vc6 iostreams/device iostreams/filter random test Message-ID: <20130504014539.F078E18512D@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:45:38 +0200 (Sat, 04 May 2013) New Revision: 41 Added: pkg/BH/inst/include/boost/detail/is_incrementable.hpp pkg/BH/inst/include/boost/iostreams/ pkg/BH/inst/include/boost/iostreams/categories.hpp pkg/BH/inst/include/boost/iostreams/chain.hpp pkg/BH/inst/include/boost/iostreams/char_traits.hpp pkg/BH/inst/include/boost/iostreams/checked_operations.hpp pkg/BH/inst/include/boost/iostreams/close.hpp pkg/BH/inst/include/boost/iostreams/code_converter.hpp pkg/BH/inst/include/boost/iostreams/combine.hpp pkg/BH/inst/include/boost/iostreams/compose.hpp pkg/BH/inst/include/boost/iostreams/concepts.hpp pkg/BH/inst/include/boost/iostreams/constants.hpp pkg/BH/inst/include/boost/iostreams/copy.hpp pkg/BH/inst/include/boost/iostreams/detail/ pkg/BH/inst/include/boost/iostreams/detail/absolute_path.hpp pkg/BH/inst/include/boost/iostreams/detail/access_control.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/ pkg/BH/inst/include/boost/iostreams/detail/adapter/concept_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/device_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/direct_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/filter_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/mode_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/non_blocking_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/output_iterator_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/adapter/range_adapter.hpp pkg/BH/inst/include/boost/iostreams/detail/add_facet.hpp pkg/BH/inst/include/boost/iostreams/detail/bool_trait_def.hpp pkg/BH/inst/include/boost/iostreams/detail/broken_overload_resolution/ pkg/BH/inst/include/boost/iostreams/detail/broken_overload_resolution/forward.hpp pkg/BH/inst/include/boost/iostreams/detail/broken_overload_resolution/stream.hpp pkg/BH/inst/include/boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp pkg/BH/inst/include/boost/iostreams/detail/buffer.hpp pkg/BH/inst/include/boost/iostreams/detail/call_traits.hpp pkg/BH/inst/include/boost/iostreams/detail/char_traits.hpp pkg/BH/inst/include/boost/iostreams/detail/codecvt_helper.hpp pkg/BH/inst/include/boost/iostreams/detail/codecvt_holder.hpp pkg/BH/inst/include/boost/iostreams/detail/config/ pkg/BH/inst/include/boost/iostreams/detail/config/auto_link.hpp pkg/BH/inst/include/boost/iostreams/detail/config/bzip2.hpp pkg/BH/inst/include/boost/iostreams/detail/config/codecvt.hpp pkg/BH/inst/include/boost/iostreams/detail/config/disable_warnings.hpp pkg/BH/inst/include/boost/iostreams/detail/config/dyn_link.hpp pkg/BH/inst/include/boost/iostreams/detail/config/enable_warnings.hpp pkg/BH/inst/include/boost/iostreams/detail/config/fpos.hpp pkg/BH/inst/include/boost/iostreams/detail/config/gcc.hpp pkg/BH/inst/include/boost/iostreams/detail/config/limits.hpp pkg/BH/inst/include/boost/iostreams/detail/config/overload_resolution.hpp pkg/BH/inst/include/boost/iostreams/detail/config/rtl.hpp pkg/BH/inst/include/boost/iostreams/detail/config/unreachable_return.hpp pkg/BH/inst/include/boost/iostreams/detail/config/wide_streams.hpp pkg/BH/inst/include/boost/iostreams/detail/config/windows_posix.hpp pkg/BH/inst/include/boost/iostreams/detail/config/zlib.hpp pkg/BH/inst/include/boost/iostreams/detail/counted_array.hpp pkg/BH/inst/include/boost/iostreams/detail/current_directory.hpp pkg/BH/inst/include/boost/iostreams/detail/default_arg.hpp pkg/BH/inst/include/boost/iostreams/detail/dispatch.hpp pkg/BH/inst/include/boost/iostreams/detail/double_object.hpp pkg/BH/inst/include/boost/iostreams/detail/enable_if_stream.hpp pkg/BH/inst/include/boost/iostreams/detail/error.hpp pkg/BH/inst/include/boost/iostreams/detail/execute.hpp pkg/BH/inst/include/boost/iostreams/detail/file_handle.hpp pkg/BH/inst/include/boost/iostreams/detail/forward.hpp pkg/BH/inst/include/boost/iostreams/detail/fstream.hpp pkg/BH/inst/include/boost/iostreams/detail/functional.hpp pkg/BH/inst/include/boost/iostreams/detail/ios.hpp pkg/BH/inst/include/boost/iostreams/detail/iostream.hpp pkg/BH/inst/include/boost/iostreams/detail/is_dereferenceable.hpp pkg/BH/inst/include/boost/iostreams/detail/is_iterator_range.hpp pkg/BH/inst/include/boost/iostreams/detail/newline.hpp pkg/BH/inst/include/boost/iostreams/detail/optional.hpp pkg/BH/inst/include/boost/iostreams/detail/param_type.hpp pkg/BH/inst/include/boost/iostreams/detail/path.hpp pkg/BH/inst/include/boost/iostreams/detail/push.hpp pkg/BH/inst/include/boost/iostreams/detail/push_params.hpp pkg/BH/inst/include/boost/iostreams/detail/resolve.hpp pkg/BH/inst/include/boost/iostreams/detail/restrict_impl.hpp pkg/BH/inst/include/boost/iostreams/detail/select.hpp pkg/BH/inst/include/boost/iostreams/detail/select_by_size.hpp pkg/BH/inst/include/boost/iostreams/detail/streambuf.hpp pkg/BH/inst/include/boost/iostreams/detail/streambuf/ pkg/BH/inst/include/boost/iostreams/detail/streambuf/chainbuf.hpp pkg/BH/inst/include/boost/iostreams/detail/streambuf/direct_streambuf.hpp pkg/BH/inst/include/boost/iostreams/detail/streambuf/indirect_streambuf.hpp pkg/BH/inst/include/boost/iostreams/detail/streambuf/linked_streambuf.hpp pkg/BH/inst/include/boost/iostreams/detail/system_failure.hpp pkg/BH/inst/include/boost/iostreams/detail/template_params.hpp pkg/BH/inst/include/boost/iostreams/detail/translate_int_type.hpp pkg/BH/inst/include/boost/iostreams/detail/vc6/ pkg/BH/inst/include/boost/iostreams/detail/vc6/close.hpp pkg/BH/inst/include/boost/iostreams/detail/vc6/read.hpp pkg/BH/inst/include/boost/iostreams/detail/vc6/write.hpp pkg/BH/inst/include/boost/iostreams/detail/wrap_unwrap.hpp pkg/BH/inst/include/boost/iostreams/device/ pkg/BH/inst/include/boost/iostreams/device/array.hpp pkg/BH/inst/include/boost/iostreams/device/back_inserter.hpp pkg/BH/inst/include/boost/iostreams/device/file.hpp pkg/BH/inst/include/boost/iostreams/device/file_descriptor.hpp pkg/BH/inst/include/boost/iostreams/device/mapped_file.hpp pkg/BH/inst/include/boost/iostreams/device/null.hpp pkg/BH/inst/include/boost/iostreams/filter/ pkg/BH/inst/include/boost/iostreams/filter/aggregate.hpp pkg/BH/inst/include/boost/iostreams/filter/bzip2.hpp pkg/BH/inst/include/boost/iostreams/filter/counter.hpp pkg/BH/inst/include/boost/iostreams/filter/grep.hpp pkg/BH/inst/include/boost/iostreams/filter/gzip.hpp pkg/BH/inst/include/boost/iostreams/filter/line.hpp pkg/BH/inst/include/boost/iostreams/filter/newline.hpp pkg/BH/inst/include/boost/iostreams/filter/regex.hpp pkg/BH/inst/include/boost/iostreams/filter/stdio.hpp pkg/BH/inst/include/boost/iostreams/filter/symmetric.hpp pkg/BH/inst/include/boost/iostreams/filter/test.hpp pkg/BH/inst/include/boost/iostreams/filter/zlib.hpp pkg/BH/inst/include/boost/iostreams/filtering_stream.hpp pkg/BH/inst/include/boost/iostreams/filtering_streambuf.hpp pkg/BH/inst/include/boost/iostreams/flush.hpp pkg/BH/inst/include/boost/iostreams/get.hpp pkg/BH/inst/include/boost/iostreams/imbue.hpp pkg/BH/inst/include/boost/iostreams/input_sequence.hpp pkg/BH/inst/include/boost/iostreams/invert.hpp pkg/BH/inst/include/boost/iostreams/operations.hpp pkg/BH/inst/include/boost/iostreams/operations_fwd.hpp pkg/BH/inst/include/boost/iostreams/optimal_buffer_size.hpp pkg/BH/inst/include/boost/iostreams/output_sequence.hpp pkg/BH/inst/include/boost/iostreams/pipeline.hpp pkg/BH/inst/include/boost/iostreams/positioning.hpp pkg/BH/inst/include/boost/iostreams/put.hpp pkg/BH/inst/include/boost/iostreams/putback.hpp pkg/BH/inst/include/boost/iostreams/read.hpp pkg/BH/inst/include/boost/iostreams/restrict.hpp pkg/BH/inst/include/boost/iostreams/seek.hpp pkg/BH/inst/include/boost/iostreams/skip.hpp pkg/BH/inst/include/boost/iostreams/slice.hpp pkg/BH/inst/include/boost/iostreams/stream.hpp pkg/BH/inst/include/boost/iostreams/stream_buffer.hpp pkg/BH/inst/include/boost/iostreams/tee.hpp pkg/BH/inst/include/boost/iostreams/traits.hpp pkg/BH/inst/include/boost/iostreams/traits_fwd.hpp pkg/BH/inst/include/boost/iostreams/write.hpp pkg/BH/inst/include/boost/random/linear_congruential.hpp pkg/BH/inst/include/boost/random/uniform_01.hpp pkg/BH/inst/include/boost/random/uniform_smallint.hpp pkg/BH/inst/include/boost/test/unit_test.hpp Log: adding 'iostreams' (#2768) Added: pkg/BH/inst/include/boost/detail/is_incrementable.hpp =================================================================== --- pkg/BH/inst/include/boost/detail/is_incrementable.hpp (rev 0) +++ pkg/BH/inst/include/boost/detail/is_incrementable.hpp 2013-05-04 01:45:38 UTC (rev 41) @@ -0,0 +1,134 @@ +// Copyright David Abrahams 2004. Use, modification and distribution is +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef IS_INCREMENTABLE_DWA200415_HPP +# define IS_INCREMENTABLE_DWA200415_HPP + +# include +# include +# include +# include +# include + +// Must be the last include +# include + +namespace boost { namespace detail { + +// is_incrementable metafunction +// +// Requires: Given x of type T&, if the expression ++x is well-formed +// it must have complete type; otherwise, it must neither be ambiguous +// nor violate access. + +// This namespace ensures that ADL doesn't mess things up. +namespace is_incrementable_ +{ + // a type returned from operator++ when no increment is found in the + // type's own namespace + struct tag {}; + + // any soaks up implicit conversions and makes the following + // operator++ less-preferred than any other such operator that + // might be found via ADL. + struct any { template any(T const&); }; + + // This is a last-resort operator++ for when none other is found +# if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2 + +} + +namespace is_incrementable_2 +{ + is_incrementable_::tag operator++(is_incrementable_::any const&); + is_incrementable_::tag operator++(is_incrementable_::any const&,int); +} +using namespace is_incrementable_2; + +namespace is_incrementable_ +{ + +# else + + tag operator++(any const&); + tag operator++(any const&,int); + +# endif + +# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ + || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_comma(a,b) (a) +# else + // In case an operator++ is found that returns void, we'll use ++x,0 + tag operator,(tag,int); +# define BOOST_comma(a,b) (a,b) +# endif + +# if defined(BOOST_MSVC) +# pragma warning(push) +# pragma warning(disable:4913) // Warning about operator, +# endif + + // two check overloads help us identify which operator++ was picked + char (& check_(tag) )[2]; + + template + char check_(T const&); + + + template + struct impl + { + static typename boost::remove_cv::type& x; + + BOOST_STATIC_CONSTANT( + bool + , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1 + ); + }; + + template + struct postfix_impl + { + static typename boost::remove_cv::type& x; + + BOOST_STATIC_CONSTANT( + bool + , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1 + ); + }; + +# if defined(BOOST_MSVC) +# pragma warning(pop) +# endif + +} + +# undef BOOST_comma + +template +struct is_incrementable +BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl::value) +{ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::impl::value) + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T)) +}; + +template +struct is_postfix_incrementable +BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl::value) +{ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::postfix_impl::value) + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T)) +}; + +} // namespace detail + +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_incrementable) +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_postfix_incrementable) + +} // namespace boost + +# include + +#endif // IS_INCREMENTABLE_DWA200415_HPP Added: pkg/BH/inst/include/boost/iostreams/categories.hpp =================================================================== --- pkg/BH/inst/include/boost/iostreams/categories.hpp (rev 0) +++ pkg/BH/inst/include/boost/iostreams/categories.hpp 2013-05-04 01:45:38 UTC (rev 41) @@ -0,0 +1,175 @@ +// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) +// (C) Copyright 2003-2007 Jonathan Turkanis +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) + +// See http://www.boost.org/libs/iostreams for documentation. + +// Contains category and mode tags for classifying filters, devices and +// standard stream and stream buffers types. + +#ifndef BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED +#define BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +namespace boost { namespace iostreams { + +//------------------Tags for dispatch according to i/o mode-------------------// + +struct any_tag { }; +namespace detail { struct two_sequence : virtual any_tag { }; } +namespace detail { struct random_access : virtual any_tag { }; } +namespace detail { struct one_head : virtual any_tag { }; } +namespace detail { struct two_head : virtual any_tag { }; } +struct input : virtual any_tag { }; +struct output : virtual any_tag { }; +struct bidirectional : virtual input, virtual output, detail::two_sequence { }; +struct dual_use : virtual input, virtual output { }; // Pseudo-mode. +struct input_seekable : virtual input, virtual detail::random_access { }; +struct output_seekable : virtual output, virtual detail::random_access { }; +struct seekable + : virtual input_seekable, + virtual output_seekable, + detail::one_head + { }; +struct dual_seekable + : virtual input_seekable, + virtual output_seekable, + detail::two_head + { }; +struct bidirectional_seekable + : input_seekable, output_seekable, + bidirectional, detail::two_head + { }; + +//------------------Tags for use as i/o categories----------------------------// + +struct device_tag : virtual any_tag { }; +struct filter_tag : virtual any_tag { }; + + // + // Tags for optional behavior. + // + +struct peekable_tag : virtual any_tag { }; // Devices. +struct closable_tag : virtual any_tag { }; +struct flushable_tag : virtual any_tag { }; +struct localizable_tag : virtual any_tag { }; +struct optimally_buffered_tag : virtual any_tag { }; +struct direct_tag : virtual any_tag { }; // Devices. +struct multichar_tag : virtual any_tag { }; // Filters. + +struct source_tag : device_tag, input { }; +struct sink_tag : device_tag, output { }; +struct bidirectional_device_tag : device_tag, bidirectional { }; +struct seekable_device_tag : virtual device_tag, seekable { }; + +struct input_filter_tag : filter_tag, input { }; +struct output_filter_tag : filter_tag, output { }; +struct bidirectional_filter_tag : filter_tag, bidirectional { }; +struct seekable_filter_tag : filter_tag, seekable { }; +struct dual_use_filter_tag : filter_tag, dual_use { }; + +struct multichar_input_filter_tag + : multichar_tag, + input_filter_tag + { }; +struct multichar_output_filter_tag + : multichar_tag, + output_filter_tag + { }; +struct multichar_bidirectional_filter_tag + : multichar_tag, + bidirectional_filter_tag + { }; +struct multichar_seekable_filter_tag + : multichar_tag, + seekable_filter_tag + { }; +struct multichar_dual_use_filter_tag + : multichar_tag, + dual_use_filter_tag + { }; + + // + // Tags for standard streams and streambufs. + // + +struct std_io_tag : virtual localizable_tag { }; +struct istream_tag + : virtual device_tag, + virtual peekable_tag, + virtual std_io_tag + { }; +struct ostream_tag + : virtual device_tag, + virtual std_io_tag + { }; +struct iostream_tag + : istream_tag, + ostream_tag + { }; +struct streambuf_tag + : device_tag, + peekable_tag, + std_io_tag + { }; +struct ifstream_tag + : input_seekable, + closable_tag, + istream_tag + { }; +struct ofstream_tag + : output_seekable, + closable_tag, + ostream_tag + { }; +struct fstream_tag + : seekable, + closable_tag, + iostream_tag + { }; +struct filebuf_tag + : seekable, + closable_tag, + streambuf_tag + { }; +struct istringstream_tag + : input_seekable, + istream_tag + { }; +struct ostringstream_tag + : output_seekable, + ostream_tag + { }; +struct stringstream_tag + : dual_seekable, + iostream_tag + { }; +struct stringbuf_tag + : dual_seekable, + streambuf_tag + { }; +struct generic_istream_tag + : input_seekable, + istream_tag + { }; +struct generic_ostream_tag + : output_seekable, + ostream_tag + { }; +struct generic_iostream_tag + : seekable, + iostream_tag + { }; +struct generic_streambuf_tag + : seekable, + streambuf_tag + { }; + +} } // End namespaces iostreams, boost. + +#endif // #ifndef BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED Added: pkg/BH/inst/include/boost/iostreams/chain.hpp =================================================================== --- pkg/BH/inst/include/boost/iostreams/chain.hpp (rev 0) +++ pkg/BH/inst/include/boost/iostreams/chain.hpp 2013-05-04 01:45:38 UTC (rev 41) @@ -0,0 +1,598 @@ +// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) +// (C) Copyright 2003-2007 Jonathan Turkanis +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) + +// See http://www.boost.org/libs/iostreams for documentation. + +#ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED +#define BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include +#include +#include // unary_function. +#include // advance. +#include +#include // allocator, auto_ptr. +#include +#include // logic_error, out_of_range. +#include +#include // BOOST_MSVC, template friends, +#include // BOOST_NESTED_TEMPLATE +#include +#include +#include +#include +#include // pubsync. +#include +#include +#include +#include // is_filter. +#include +#include +#include +#include +#include +#include +#include +#include // VC6.5 requires this +#if BOOST_WORKAROUND(BOOST_MSVC, < 1310) // #include order +# include +#endif + +// Sometimes type_info objects must be compared by name. Borrowed from +// Boost.Python and Boost.Function. +#if (defined(__GNUC__) && __GNUC__ >= 3) || \ + defined(_AIX) || \ + (defined(__sgi) && defined(__host_mips)) || \ + (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC)) \ + /**/ +# include +# define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) \ + (std::strcmp((X).name(),(Y).name()) == 0) +#else +# define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) ((X)==(Y)) +#endif + +// Deprecated +#define BOOST_IOSTREAMS_COMPONENT_TYPE(chain, index) \ + chain.component_type( index ) \ + /**/ + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) +# define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \ + chain.component< target >( index ) \ + /**/ +#else +# define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \ + chain.component( index, ::boost::type< target >() ) \ + /**/ +#endif + +namespace boost { namespace iostreams { + +//--------------Definition of chain and wchain--------------------------------// + +namespace detail { + +template class chain_client; + +// +// Concept name: Chain. +// Description: Represents a chain of stream buffers which provides access +// to the first buffer in the chain and sends notifications when the +// streambufs are added to or removed from chain. +// Refines: Closable device with mode equal to typename Chain::mode. +// Models: chain, converting_chain. +// Example: +// +// class chain { +// public: +// typedef xxx chain_type; +// typedef xxx client_type; +// typedef xxx mode; +// bool is_complete() const; // Ready for i/o. +// template +// void push( const T& t, // Adds a stream buffer to +// streamsize, // chain, based on t, with +// streamsize ); // given buffer and putback +// // buffer sizes. Pass -1 to +// // request default size. +// protected: +// void register_client(client_type* client); // Associate client. +// void notify(); // Notify client. +// }; +// + +// +// Description: Represents a chain of filters with an optional device at the +// end. +// Template parameters: +// Self - A class deriving from the current instantiation of this template. +// This is an example of the Curiously Recurring Template Pattern. +// Ch - The character type. +// Tr - The character traits type. +// Alloc - The allocator type. +// Mode - A mode tag. +// +template +class chain_base { +public: + typedef Ch char_type; + BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) + typedef Alloc allocator_type; + typedef Mode mode; + struct category + : Mode, + device_tag + { }; + typedef chain_client client_type; + friend class chain_client; +private: + typedef linked_streambuf streambuf_type; + typedef std::list list_type; + typedef chain_base my_type; +protected: + chain_base() : pimpl_(new chain_impl) { } + chain_base(const chain_base& rhs): pimpl_(rhs.pimpl_) { } +public: + + // dual_use is a pseudo-mode to facilitate filter writing, + // not a genuine mode. + BOOST_STATIC_ASSERT((!is_convertible::value)); + + //----------Buffer sizing-------------------------------------------------// + + // Sets the size of the buffer created for the devices to be added to this + // chain. Does not affect the size of the buffer for devices already + // added. + void set_device_buffer_size(std::streamsize n) + { pimpl_->device_buffer_size_ = n; } + + // Sets the size of the buffer created for the filters to be added + // to this chain. Does not affect the size of the buffer for filters already + // added. + void set_filter_buffer_size(std::streamsize n) + { pimpl_->filter_buffer_size_ = n; } + + // Sets the size of the putback buffer for filters and devices to be added + // to this chain. Does not affect the size of the buffer for filters or + // devices already added. + void set_pback_size(std::streamsize n) + { pimpl_->pback_size_ = n; } + + //----------Device interface----------------------------------------------// + + std::streamsize read(char_type* s, std::streamsize n); + std::streamsize write(const char_type* s, std::streamsize n); + std::streampos seek(stream_offset off, BOOST_IOS::seekdir way); + + //----------Direct component access---------------------------------------// + + const std::type_info& component_type(int n) const + { + if (static_cast(n) >= size()) + boost::throw_exception(std::out_of_range("bad chain offset")); + return (*boost::next(list().begin(), n))->component_type(); + } + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) + // Deprecated. + template + const std::type_info& component_type() const { return component_type(N); } + + template + T* component(int n) const { return component(n, boost::type()); } + + // Deprecated. + template + T* component() const { return component(N); } +#endif + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) + private: +#endif + template + T* component(int n, boost::type) const + { + if (static_cast(n) >= size()) + boost::throw_exception(std::out_of_range("bad chain offset")); + streambuf_type* link = *boost::next(list().begin(), n); + if (BOOST_IOSTREAMS_COMPARE_TYPE_ID(link->component_type(), typeid(T))) + return static_cast(link->component_impl()); + else + return 0; + } +public: + + //----------Container-like interface--------------------------------------// + + typedef typename list_type::size_type size_type; + streambuf_type& front() { return *list().front(); } + BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl) + void pop(); + bool empty() const { return list().empty(); } + size_type size() const { return list().size(); } + void reset(); + + //----------Additional i/o functions--------------------------------------// + + // Returns true if this chain is non-empty and its final link + // is a source or sink, i.e., if it is ready to perform i/o. + bool is_complete() const; + bool auto_close() const; + void set_auto_close(bool close); + bool sync() { return front().BOOST_IOSTREAMS_PUBSYNC() != -1; } + bool strict_sync(); +private: + template + void push_impl(const T& t, std::streamsize buffer_size = -1, + std::streamsize pback_size = -1) + { + typedef typename iostreams::category_of::type category; + typedef typename unwrap_ios::type component_type; + typedef stream_buffer< + component_type, + BOOST_IOSTREAMS_CHAR_TRAITS(char_type), + Alloc, Mode + > streambuf_t; + typedef typename list_type::iterator iterator; + BOOST_STATIC_ASSERT((is_convertible::value)); + if (is_complete()) + boost::throw_exception(std::logic_error("chain complete")); + streambuf_type* prev = !empty() ? list().back() : 0; + buffer_size = + buffer_size != -1 ? + buffer_size : + iostreams::optimal_buffer_size(t); + pback_size = + pback_size != -1 ? + pback_size : + pimpl_->pback_size_; + std::auto_ptr + buf(new streambuf_t(t, buffer_size, pback_size)); + list().push_back(buf.get()); + buf.release(); + if (is_device::value) { + pimpl_->flags_ |= f_complete | f_open; + for ( iterator first = list().begin(), + last = list().end(); + first != last; + ++first ) + { + (*first)->set_needs_close(); + } + } + if (prev) prev->set_next(list().back()); + notify(); + } + + list_type& list() { return pimpl_->links_; } + const list_type& list() const { return pimpl_->links_; } + void register_client(client_type* client) { pimpl_->client_ = client; } + void notify() { if (pimpl_->client_) pimpl_->client_->notify(); } + + //----------Nested classes------------------------------------------------// + + static void close(streambuf_type* b, BOOST_IOS::openmode m) + { + if (m == BOOST_IOS::out && is_convertible::value) + b->BOOST_IOSTREAMS_PUBSYNC(); + b->close(m); + } + + static void set_next(streambuf_type* b, streambuf_type* next) + { b->set_next(next); } + + static void set_auto_close(streambuf_type* b, bool close) + { b->set_auto_close(close); } + + struct closer : public std::unary_function { + closer(BOOST_IOS::openmode m) : mode_(m) { } + void operator() (streambuf_type* b) + { + close(b, mode_); + } + BOOST_IOS::openmode mode_; + }; + friend struct closer; + + enum flags { + f_complete = 1, + f_open = 2, + f_auto_close = 4 + }; + + struct chain_impl { + chain_impl() + : client_(0), device_buffer_size_(default_device_buffer_size), + filter_buffer_size_(default_filter_buffer_size), + pback_size_(default_pback_buffer_size), + flags_(f_auto_close) + { } + ~chain_impl() + { + try { close(); } catch (...) { } + try { reset(); } catch (...) { } + } + void close() + { + if ((flags_ & f_open) != 0) { + flags_ &= ~f_open; + stream_buffer< basic_null_device > null; + if ((flags_ & f_complete) == 0) { + null.open(basic_null_device()); + set_next(links_.back(), &null); + } + links_.front()->BOOST_IOSTREAMS_PUBSYNC(); + try { + boost::iostreams::detail::execute_foreach( + links_.rbegin(), links_.rend(), + closer(BOOST_IOS::in) + ); + } catch (...) { + try { + boost::iostreams::detail::execute_foreach( + links_.begin(), links_.end(), + closer(BOOST_IOS::out) + ); + } catch (...) { } + throw; + } + boost::iostreams::detail::execute_foreach( + links_.begin(), links_.end(), + closer(BOOST_IOS::out) + ); + } + } + void reset() + { + typedef typename list_type::iterator iterator; + for ( iterator first = links_.begin(), + last = links_.end(); + first != last; + ++first ) + { + if ( (flags_ & f_complete) == 0 || + (flags_ & f_auto_close) == 0 ) + { + set_auto_close(*first, false); + } + streambuf_type* buf = 0; + std::swap(buf, *first); + delete buf; + } + links_.clear(); + flags_ &= ~f_complete; + flags_ &= ~f_open; + } + list_type links_; + client_type* client_; + std::streamsize device_buffer_size_, + filter_buffer_size_, + pback_size_; + int flags_; + }; + friend struct chain_impl; + + //----------Member data---------------------------------------------------// + +private: + shared_ptr pimpl_; +}; + +} // End namespace detail. + +// +// Macro: BOOST_IOSTREAMS_DECL_CHAIN(name, category) +// Description: Defines a template derived from chain_base appropriate for a +// particular i/o category. The template has the following parameters: +// Ch - The character type. +// Tr - The character traits type. +// Alloc - The allocator type. +// Macro parameters: +// name_ - The name of the template to be defined. +// category_ - The i/o category of the template to be defined. +// +#define BOOST_IOSTREAMS_DECL_CHAIN(name_, default_char_) \ + template< typename Mode, typename Ch = default_char_, \ + typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \ + typename Alloc = std::allocator > \ + class name_ : public boost::iostreams::detail::chain_base< \ + name_, \ + Ch, Tr, Alloc, Mode \ + > \ + { \ + public: \ + struct category : device_tag, Mode { }; \ + typedef Mode mode; \ + private: \ + typedef boost::iostreams::detail::chain_base< \ + name_, \ + Ch, Tr, Alloc, Mode \ + > base_type; \ + public: \ + typedef Ch char_type; \ + typedef Tr traits_type; \ + typedef typename traits_type::int_type int_type; \ + typedef typename traits_type::off_type off_type; \ + name_() { } \ + name_(const name_& rhs) : base_type(rhs) { } \ + name_& operator=(const name_& rhs) \ + { base_type::operator=(rhs); return *this; } \ + }; \ + /**/ +BOOST_IOSTREAMS_DECL_CHAIN(chain, char) +BOOST_IOSTREAMS_DECL_CHAIN(wchain, wchar_t) +#undef BOOST_IOSTREAMS_DECL_CHAIN + +//--------------Definition of chain_client------------------------------------// + +namespace detail { + +// +// Template name: chain_client +// Description: Class whose instances provide access to an underlying chain +// using an interface similar to the chains. +// Subclasses: the various stream and stream buffer templates. +// +template +class chain_client { +public: + typedef Chain chain_type; + typedef typename chain_type::char_type char_type; + typedef typename chain_type::traits_type traits_type; + typedef typename chain_type::size_type size_type; + typedef typename chain_type::mode mode; + + chain_client(chain_type* chn = 0) : chain_(chn ) { } + chain_client(chain_client* client) : chain_(client->chain_) { } + virtual ~chain_client() { } + + const std::type_info& component_type(int n) const + { return chain_->component_type(n); } + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) + // Deprecated. + template + const std::type_info& component_type() const + { return chain_->BOOST_NESTED_TEMPLATE component_type(); } + + template + T* component(int n) const + { return chain_->BOOST_NESTED_TEMPLATE component(n); } + + // Deprecated. + template + T* component() const + { return chain_->BOOST_NESTED_TEMPLATE component(); } +#else + template + T* component(int n, boost::type t) const + { return chain_->component(n, t); } +#endif + + bool is_complete() const { return chain_->is_complete(); } + bool auto_close() const { return chain_->auto_close(); } + void set_auto_close(bool close) { chain_->set_auto_close(close); } + bool strict_sync() { return chain_->strict_sync(); } + void set_device_buffer_size(std::streamsize n) + { chain_->set_device_buffer_size(n); } + void set_filter_buffer_size(std::streamsize n) + { chain_->set_filter_buffer_size(n); } + void set_pback_size(std::streamsize n) { chain_->set_pback_size(n); } + BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl) + void pop() { chain_->pop(); } + bool empty() const { return chain_->empty(); } + size_type size() { return chain_->size(); } + void reset() { chain_->reset(); } + + // Returns a copy of the underlying chain. + chain_type filters() { return *chain_; } + chain_type filters() const { return *chain_; } +protected: + template + void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS()) + { chain_->push(t BOOST_IOSTREAMS_PUSH_ARGS()); } + chain_type& ref() { return *chain_; } + void set_chain(chain_type* c) + { chain_ = c; chain_->register_client(this); } +#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && \ + (!BOOST_WORKAROUND(__BORLANDC__, < 0x600)) + template + friend class chain_base; +#else + public: +#endif + virtual void notify() { } +private: + chain_type* chain_; +}; + +//--------------Implementation of chain_base----------------------------------// + +template +inline std::streamsize chain_base::read + (char_type* s, std::streamsize n) +{ return iostreams::read(*list().front(), s, n); } + +template +inline std::streamsize chain_base::write + (const char_type* s, std::streamsize n) +{ return iostreams::write(*list().front(), s, n); } + +template +inline std::streampos chain_base::seek + (stream_offset off, BOOST_IOS::seekdir way) +{ return iostreams::seek(*list().front(), off, way); } + +template +void chain_base::reset() +{ + using namespace std; + pimpl_->close(); + pimpl_->reset(); +} + +template +bool chain_base::is_complete() const +{ + return (pimpl_->flags_ & f_complete) != 0; +} + +template +bool chain_base::auto_close() const +{ + return (pimpl_->flags_ & f_auto_close) != 0; +} + +template +void chain_base::set_auto_close(bool close) +{ + pimpl_->flags_ = + (pimpl_->flags_ & ~f_auto_close) | + (close ? f_auto_close : 0); +} + +template +bool chain_base::strict_sync() +{ + typedef typename list_type::iterator iterator; + bool result = true; + for ( iterator first = list().begin(), + last = list().end(); + first != last; + ++first ) + { + bool s = (*first)->strict_sync(); + result = result && s; + } + return result; +} + +template +void chain_base::pop() +{ + BOOST_ASSERT(!empty()); + if (auto_close()) + pimpl_->close(); + streambuf_type* buf = 0; + std::swap(buf, list().back()); + buf->set_auto_close(false); + buf->set_next(0); + delete buf; + list().pop_back(); + pimpl_->flags_ &= ~f_complete; + if (auto_close() || list().empty()) + pimpl_->flags_ &= ~f_open; +} + +} // End namespace detail. + +} } // End namespaces iostreams, boost. + +#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED Added: pkg/BH/inst/include/boost/iostreams/char_traits.hpp =================================================================== --- pkg/BH/inst/include/boost/iostreams/char_traits.hpp (rev 0) +++ pkg/BH/inst/include/boost/iostreams/char_traits.hpp 2013-05-04 01:45:38 UTC (rev 41) @@ -0,0 +1,73 @@ +// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) +// (C) Copyright 2003-2007 Jonathan Turkanis +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) + +// See http://www.boost.org/libs/iostreams for documentation. + +#ifndef BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED +#define BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include +#include +#include // EOF. +#include // std::char_traits. +#include +#include +#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS +# include +#endif + +#ifdef BOOST_NO_STDC_NAMESPACE +namespace std { using ::wint_t; } +#endif + +namespace boost { namespace iostreams { + +// Dinkumware that comes with QNX Momentics 6.3.0, 4.0.2, incorrectly defines [TRUNCATED] To get the complete diff run: svnlook diff /svnroot/boostheaders -r 41 From noreply at r-forge.r-project.org Sat May 4 03:46:55 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 03:46:55 +0200 (CEST) Subject: [Boostheaders-commits] r42 - / Message-ID: <20130504014655.49536185164@r-forge.r-project.org> Author: edd Date: 2013-05-04 03:46:54 +0200 (Sat, 04 May 2013) New Revision: 42 Modified: CreateBoost.sh Log: corrected to include 'iostreams' (#2768) Modified: CreateBoost.sh =================================================================== --- CreateBoost.sh 2013-05-04 01:45:38 UTC (rev 41) +++ CreateBoost.sh 2013-05-04 01:46:54 UTC (rev 42) @@ -87,8 +87,8 @@ bcp --boost=${boostroot} math/distributions ${pkgdir}/inst/include >> bcp.log bcp --boost=${boostroot} algorithm ${pkgdir}/inst/include >> bcp.log -# Plus iostream (cf issue ticket #2768) -- thia is a null-op, why? -bcp --boost=${boostroot} iostream ${pkgdir}/inst/include >> bcp.log +# Plus iostream (cf issue ticket #2768) +bcp --boost=${boostroot} iostreams ${pkgdir}/inst/include >> bcp.log # TODO: check with other packages @@ -97,7 +97,8 @@ rm -rf ${pkgdir}/inst/include/libs \ ${pkgdir}/inst/include/Jamroot \ ${pkgdir}/inst/include/boost.png \ - ${pkgdir}/inst/include/doc + ${pkgdir}/inst/include/doc \ + ${pkgdir}/inst/include/boost.css cp BoostHeadersROOT/LICENSE* \ BoostHeadersROOT/NAMESPACE ${pkgdir} From noreply at r-forge.r-project.org Sat May 4 16:41:52 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 16:41:52 +0200 (CEST) Subject: [Boostheaders-commits] r43 - / BoostHeadersROOT BoostHeadersROOT/inst pkg/BH/inst Message-ID: <20130504144152.72236184E1A@r-forge.r-project.org> Author: edd Date: 2013-05-04 16:41:51 +0200 (Sat, 04 May 2013) New Revision: 43 Added: BoostHeadersROOT/inst/ BoostHeadersROOT/inst/NEWS.Rd pkg/BH/inst/NEWS.Rd Modified: CreateBoost.sh Log: adding a NEWS.Rd file for the package, and making sure it is installed Added: BoostHeadersROOT/inst/NEWS.Rd =================================================================== --- BoostHeadersROOT/inst/NEWS.Rd (rev 0) +++ BoostHeadersROOT/inst/NEWS.Rd 2013-05-04 14:41:51 UTC (rev 43) @@ -0,0 +1,28 @@ +\name{NEWS} +\title{News for Package \pkg{BH}} +\newcommand{\cpkg}{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} +\newcommand{\boost}{\href{http://www.boost.org}{\pkg{Boost}}} + +\section{Changes in [unreleased] version 1.51.0-1 (2013-05-04)}{ + \itemize{ + \item Expanded \boost coverage by adding \boost packages + \href{http://www.boost.org/doc/libs/release/libs/foreach}{\pkg{foreach}}, + \href{http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{{\pkg{Statistical + Distributions}} and + \href{http://www.boost.org/doc/libs/release/libs/iostreams}{\pkg{iostreams}} + (which addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). + } +} + +\section{Changes in version 1.51.0-0 (2013-01-31)}{ + \itemize{ + \item First CRAN upload + \item Package can be used to successfully build \cpkg{bigmemory} and + \cpkg{RcppBDT}. It already contains significant portions of Boost libraries + algorithm, bind, concept, config, container, date_time, detail, + exceptions, filesystem, functional, interprocess, intrusive, iterator, + math, mpl, numeric, preprocessor, random, range, smart_ptr, + type_traits, unordered. + } +} + Modified: CreateBoost.sh =================================================================== --- CreateBoost.sh 2013-05-04 01:46:54 UTC (rev 42) +++ CreateBoost.sh 2013-05-04 14:41:51 UTC (rev 43) @@ -100,9 +100,10 @@ ${pkgdir}/inst/include/doc \ ${pkgdir}/inst/include/boost.css -cp BoostHeadersROOT/LICENSE* \ - BoostHeadersROOT/NAMESPACE ${pkgdir} -cp -p BoostHeadersROOT/man/*.Rd ${pkgdir}/man +cp -p BoostHeadersROOT/LICENSE* \ + BoostHeadersROOT/NAMESPACE ${pkgdir} +cp -p BoostHeadersROOT/inst/NEWS.Rd ${pkgdir}/inst/ +cp -p BoostHeadersROOT/man/*.Rd ${pkgdir}/man sed -e "s/XXX/${version}/g" \ -e "s/YYY/${date}/g" \ Added: pkg/BH/inst/NEWS.Rd =================================================================== --- pkg/BH/inst/NEWS.Rd (rev 0) +++ pkg/BH/inst/NEWS.Rd 2013-05-04 14:41:51 UTC (rev 43) @@ -0,0 +1,28 @@ +\name{NEWS} +\title{News for Package \pkg{BH}} +\newcommand{\cpkg}{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} +\newcommand{\boost}{\href{http://www.boost.org}{\pkg{Boost}}} + +\section{Changes in [unreleased] version 1.51.0-1 (2013-05-04)}{ + \itemize{ + \item Expanded \boost coverage by adding \boost packages + \href{http://www.boost.org/doc/libs/release/libs/foreach}{\pkg{foreach}}, + \href{http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{{\pkg{Statistical + Distributions}} and + \href{http://www.boost.org/doc/libs/release/libs/iostreams}{\pkg{iostreams}} + (which addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). + } +} + +\section{Changes in version 1.51.0-0 (2013-01-31)}{ + \itemize{ + \item First CRAN upload + \item Package can be used to successfully build \cpkg{bigmemory} and + \cpkg{RcppBDT}. It already contains significant portions of Boost libraries + algorithm, bind, concept, config, container, date_time, detail, + exceptions, filesystem, functional, interprocess, intrusive, iterator, + math, mpl, numeric, preprocessor, random, range, smart_ptr, + type_traits, unordered. + } +} + From noreply at r-forge.r-project.org Sat May 4 16:57:05 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 16:57:05 +0200 (CEST) Subject: [Boostheaders-commits] r44 - BoostHeadersROOT/inst Message-ID: <20130504145705.A705418517B@r-forge.r-project.org> Author: edd Date: 2013-05-04 16:57:05 +0200 (Sat, 04 May 2013) New Revision: 44 Modified: BoostHeadersROOT/inst/NEWS.Rd Log: some edits Modified: BoostHeadersROOT/inst/NEWS.Rd =================================================================== --- BoostHeadersROOT/inst/NEWS.Rd 2013-05-04 14:41:51 UTC (rev 43) +++ BoostHeadersROOT/inst/NEWS.Rd 2013-05-04 14:57:05 UTC (rev 44) @@ -2,23 +2,23 @@ \title{News for Package \pkg{BH}} \newcommand{\cpkg}{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} \newcommand{\boost}{\href{http://www.boost.org}{\pkg{Boost}}} +\newcommand{\boostPkg}{\href{http://www.boost.org/doc/libs/release/libs/#1}{\pkg{#1}}} +\newcommand{\boostPkgTwo}{\href{http://www.boost.org/doc/libs/release/libs/#1}{\pkg{#2}}} \section{Changes in [unreleased] version 1.51.0-1 (2013-05-04)}{ \itemize{ - \item Expanded \boost coverage by adding \boost packages - \href{http://www.boost.org/doc/libs/release/libs/foreach}{\pkg{foreach}}, - \href{http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{{\pkg{Statistical - Distributions}} and - \href{http://www.boost.org/doc/libs/release/libs/iostreams}{\pkg{iostreams}} - (which addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). + \item Expanded \boost coverage by adding \boost packages \boostPkg{foreach}, + \boostPkgTwo{libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{statistical distributions}, + and \boostPkg{iostreams}. This addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). + \item The package can now also be used to compile \pkg{ExactNumCI}. } } \section{Changes in version 1.51.0-0 (2013-01-31)}{ \itemize{ \item First CRAN upload - \item Package can be used to successfully build \cpkg{bigmemory} and - \cpkg{RcppBDT}. It already contains significant portions of Boost libraries + \item The package can be used to build \cpkg{bigmemory} and + \cpkg{RcppBDT} as it already contains significant portions of Boost libraries algorithm, bind, concept, config, container, date_time, detail, exceptions, filesystem, functional, interprocess, intrusive, iterator, math, mpl, numeric, preprocessor, random, range, smart_ptr, From noreply at r-forge.r-project.org Sat May 4 18:05:24 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 4 May 2013 18:05:24 +0200 (CEST) Subject: [Boostheaders-commits] r45 - / BoostHeadersROOT/inst Message-ID: <20130504160524.E262A18518D@r-forge.r-project.org> Author: edd Date: 2013-05-04 18:05:24 +0200 (Sat, 04 May 2013) New Revision: 45 Modified: BoostHeadersROOT/inst/NEWS.Rd README Log: tested with Whit's rcppbugs as well Modified: BoostHeadersROOT/inst/NEWS.Rd =================================================================== --- BoostHeadersROOT/inst/NEWS.Rd 2013-05-04 14:57:05 UTC (rev 44) +++ BoostHeadersROOT/inst/NEWS.Rd 2013-05-04 16:05:24 UTC (rev 45) @@ -10,7 +10,8 @@ \item Expanded \boost coverage by adding \boost packages \boostPkg{foreach}, \boostPkgTwo{libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{statistical distributions}, and \boostPkg{iostreams}. This addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). - \item The package can now also be used to compile \pkg{ExactNumCI}. + \item The package can now also be used to compile CRAN package + \pkg{ExactNumCI} and \pkg{rcppbugs}. } } Modified: README =================================================================== --- README 2013-05-04 14:57:05 UTC (rev 44) +++ README 2013-05-04 16:05:24 UTC (rev 45) @@ -1 +1 @@ -See CreateBoost.R for now. +See CreateBoost.R for now. Also see CreateBoost.sh which may replace it. From noreply at r-forge.r-project.org Sat May 18 19:59:32 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Sat, 18 May 2013 19:59:32 +0200 (CEST) Subject: [Boostheaders-commits] r46 - pkg/BH/inst Message-ID: <20130518175932.D8E1A184C9A@r-forge.r-project.org> Author: edd Date: 2013-05-18 19:59:32 +0200 (Sat, 18 May 2013) New Revision: 46 Modified: pkg/BH/inst/NEWS.Rd Log: updated comments Modified: pkg/BH/inst/NEWS.Rd =================================================================== --- pkg/BH/inst/NEWS.Rd 2013-05-04 16:05:24 UTC (rev 45) +++ pkg/BH/inst/NEWS.Rd 2013-05-18 17:59:32 UTC (rev 46) @@ -2,23 +2,24 @@ \title{News for Package \pkg{BH}} \newcommand{\cpkg}{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} \newcommand{\boost}{\href{http://www.boost.org}{\pkg{Boost}}} +\newcommand{\boostPkg}{\href{http://www.boost.org/doc/libs/release/libs/#1}{\pkg{#1}}} +\newcommand{\boostPkgTwo}{\href{http://www.boost.org/doc/libs/release/libs/#1}{\pkg{#2}}} \section{Changes in [unreleased] version 1.51.0-1 (2013-05-04)}{ \itemize{ - \item Expanded \boost coverage by adding \boost packages - \href{http://www.boost.org/doc/libs/release/libs/foreach}{\pkg{foreach}}, - \href{http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{{\pkg{Statistical - Distributions}} and - \href{http://www.boost.org/doc/libs/release/libs/iostreams}{\pkg{iostreams}} - (which addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). + \item Expanded \boost coverage by adding \boost packages \boostPkg{foreach}, + \boostPkgTwo{libs/math/doc/sf_and_dist/html/math_toolkit/dist.html}{statistical distributions}, + and \boostPkg{iostreams}. This addresses, respectively, R-Forge issue tickets 2527, 2533 and 2768). + \item The package can now also be used to compile CRAN package + \pkg{ExactNumCI} and \pkg{rcppbugs}. } } \section{Changes in version 1.51.0-0 (2013-01-31)}{ \itemize{ \item First CRAN upload - \item Package can be used to successfully build \cpkg{bigmemory} and - \cpkg{RcppBDT}. It already contains significant portions of Boost libraries + \item The package can be used to build \cpkg{bigmemory} and + \cpkg{RcppBDT} as it already contains significant portions of Boost libraries algorithm, bind, concept, config, container, date_time, detail, exceptions, filesystem, functional, interprocess, intrusive, iterator, math, mpl, numeric, preprocessor, random, range, smart_ptr, From noreply at r-forge.r-project.org Tue May 28 14:40:39 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Tue, 28 May 2013 14:40:39 +0200 (CEST) Subject: [Boostheaders-commits] r47 - in pkg/BH: . man Message-ID: <20130528124040.0C24F1853D9@r-forge.r-project.org> Author: jayemerson Date: 2013-05-28 14:40:39 +0200 (Tue, 28 May 2013) New Revision: 47 Modified: pkg/BH/DESCRIPTION pkg/BH/man/BH-package.Rd Log: Modified: pkg/BH/DESCRIPTION =================================================================== --- pkg/BH/DESCRIPTION 2013-05-18 17:59:32 UTC (rev 46) +++ pkg/BH/DESCRIPTION 2013-05-28 12:40:39 UTC (rev 47) @@ -2,7 +2,7 @@ Type: Package Title: The Boost C++ Libraries Version: 1.51.0-1 -Date: 2013-05-02 +Date: 2013-05-28 Author: John W. Emerson, Michael J. Kane, Dirk Eddelbuettel, JJ Allaire, and Romain Francois Maintainer: Jay Emerson Description: Boost provides free peer-reviewed portable C++ source Modified: pkg/BH/man/BH-package.Rd =================================================================== --- pkg/BH/man/BH-package.Rd 2013-05-18 17:59:32 UTC (rev 46) +++ pkg/BH/man/BH-package.Rd 2013-05-28 12:40:39 UTC (rev 47) @@ -15,7 +15,7 @@ Package: \tab BH\cr Type: \tab Package\cr Version: \tab 1.51.0-1\cr -Date: \tab 2013-05-02\cr +Date: \tab 2013-05-28\cr License: \tab BSL-1.0\cr } Boost provides free peer-reviewed portable C++ source From noreply at r-forge.r-project.org Tue May 28 20:59:59 2013 From: noreply at r-forge.r-project.org (noreply at r-forge.r-project.org) Date: Tue, 28 May 2013 20:59:59 +0200 (CEST) Subject: [Boostheaders-commits] r48 - / BoostHeadersROOT pkg/BH Message-ID: <20130528185959.7B418185108@r-forge.r-project.org> Author: jayemerson Date: 2013-05-28 20:59:58 +0200 (Tue, 28 May 2013) New Revision: 48 Removed: BoostHeadersROOT/LICENSE BoostHeadersROOT/LICENSE_1_0.txt pkg/BH/LICENSE pkg/BH/LICENSE_1_0.txt Modified: CreateBoost.sh Log: Deleted: BoostHeadersROOT/LICENSE =================================================================== --- BoostHeadersROOT/LICENSE 2013-05-28 12:40:39 UTC (rev 47) +++ BoostHeadersROOT/LICENSE 2013-05-28 18:59:58 UTC (rev 48) @@ -1,3 +0,0 @@ -# Distributed under the Boost Software License, Version 1.0. -# See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt Deleted: BoostHeadersROOT/LICENSE_1_0.txt =================================================================== --- BoostHeadersROOT/LICENSE_1_0.txt 2013-05-28 12:40:39 UTC (rev 47) +++ BoostHeadersROOT/LICENSE_1_0.txt 2013-05-28 18:59:58 UTC (rev 48) @@ -1,24 +0,0 @@ -Boost Software License - Version 1.0 - August 17th, 2003 - -Permission is hereby granted, free of charge, to any person or organization -obtaining a copy of the software and accompanying documentation covered by -this license (the "Software") to use, reproduce, display, distribute, -execute, and transmit the Software, and to prepare derivative works of the -Software, and to permit third-parties to whom the Software is furnished to -do so, all subject to the following: - -The copyright notices in the Software and this entire statement, including -the above license grant, this restriction and the following disclaimer, -must be included in all copies of the Software, in whole or in part, and -all derivative works of the Software, unless such copies or derivative -works are solely in the form of machine-executable object code generated by -a source language processor. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT -SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE -FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, -ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. - Modified: CreateBoost.sh =================================================================== --- CreateBoost.sh 2013-05-28 12:40:39 UTC (rev 47) +++ CreateBoost.sh 2013-05-28 18:59:58 UTC (rev 48) @@ -8,7 +8,7 @@ ## set the variables boostall and version, here: boostall="boost_1_51_0.tar.gz" version="1.51.0-1" -date="2013-05-02" +date="2013-05-28" pkgdir="pkg/BH" @@ -100,8 +100,7 @@ ${pkgdir}/inst/include/doc \ ${pkgdir}/inst/include/boost.css -cp -p BoostHeadersROOT/LICENSE* \ - BoostHeadersROOT/NAMESPACE ${pkgdir} +cp -p BoostHeadersROOT/NAMESPACE ${pkgdir} cp -p BoostHeadersROOT/inst/NEWS.Rd ${pkgdir}/inst/ cp -p BoostHeadersROOT/man/*.Rd ${pkgdir}/man Deleted: pkg/BH/LICENSE =================================================================== --- pkg/BH/LICENSE 2013-05-28 12:40:39 UTC (rev 47) +++ pkg/BH/LICENSE 2013-05-28 18:59:58 UTC (rev 48) @@ -1,3 +0,0 @@ -# Distributed under the Boost Software License, Version 1.0. -# See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt Deleted: pkg/BH/LICENSE_1_0.txt =================================================================== --- pkg/BH/LICENSE_1_0.txt 2013-05-28 12:40:39 UTC (rev 47) +++ pkg/BH/LICENSE_1_0.txt 2013-05-28 18:59:58 UTC (rev 48) @@ -1,24 +0,0 @@ -Boost Software License - Version 1.0 - August 17th, 2003 - -Permission is hereby granted, free of charge, to any person or organization -obtaining a copy of the software and accompanying documentation covered by -this license (the "Software") to use, reproduce, display, distribute, -execute, and transmit the Software, and to prepare derivative works of the -Software, and to permit third-parties to whom the Software is furnished to -do so, all subject to the following: - -The copyright notices in the Software and this entire statement, including -the above license grant, this restriction and the following disclaimer, -must be included in all copies of the Software, in whole or in part, and -all derivative works of the Software, unless such copies or derivative -works are solely in the form of machine-executable object code generated by -a source language processor. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT -SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE -FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, -ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. -