Updated boost to v1.55.0
authorBo Li <bli@lucille.lucille.berkeley.edu>
Fri, 6 Jun 2014 09:15:18 +0000 (02:15 -0700)
committerBo Li <bli@lucille.lucille.berkeley.edu>
Fri, 6 Jun 2014 09:15:18 +0000 (02:15 -0700)
1144 files changed:
boost/array.hpp
boost/assert.hpp
boost/blank.hpp [new file with mode: 0644]
boost/blank_fwd.hpp [new file with mode: 0644]
boost/call_traits.hpp [deleted file]
boost/concept/assert.hpp [new file with mode: 0644]
boost/concept/detail/backward_compatibility.hpp [new file with mode: 0644]
boost/concept/detail/borland.hpp [new file with mode: 0644]
boost/concept/detail/concept_def.hpp [new file with mode: 0644]
boost/concept/detail/concept_undef.hpp [new file with mode: 0644]
boost/concept/detail/general.hpp [new file with mode: 0644]
boost/concept/detail/has_constraints.hpp [new file with mode: 0644]
boost/concept/detail/msvc.hpp [new file with mode: 0644]
boost/concept/usage.hpp [new file with mode: 0644]
boost/concept_check.hpp [new file with mode: 0644]
boost/config.hpp
boost/config/auto_link.hpp
boost/config/compiler/borland.hpp
boost/config/compiler/clang.hpp
boost/config/compiler/codegear.hpp
boost/config/compiler/common_edg.hpp
boost/config/compiler/cray.hpp [new file with mode: 0644]
boost/config/compiler/digitalmars.hpp
boost/config/compiler/gcc.hpp
boost/config/compiler/gcc_xml.hpp
boost/config/compiler/hp_acc.hpp
boost/config/compiler/intel.hpp
boost/config/compiler/metrowerks.hpp
boost/config/compiler/mpw.hpp
boost/config/compiler/nvcc.hpp
boost/config/compiler/pathscale.hpp [new file with mode: 0644]
boost/config/compiler/pgi.hpp
boost/config/compiler/sunpro_cc.hpp
boost/config/compiler/vacpp.hpp
boost/config/compiler/visualc.hpp
boost/config/platform/bsd.hpp
boost/config/platform/cray.hpp [new file with mode: 0644]
boost/config/platform/cygwin.hpp
boost/config/platform/linux.hpp
boost/config/platform/macos.hpp
boost/config/platform/symbian.hpp
boost/config/platform/vms.hpp [new file with mode: 0644]
boost/config/platform/vxworks.hpp
boost/config/platform/win32.hpp
boost/config/select_compiler_config.hpp
boost/config/select_platform_config.hpp
boost/config/select_stdlib_config.hpp
boost/config/stdlib/dinkumware.hpp
boost/config/stdlib/libcomo.hpp
boost/config/stdlib/libcpp.hpp [new file with mode: 0644]
boost/config/stdlib/libstdcpp3.hpp
boost/config/stdlib/modena.hpp
boost/config/stdlib/msl.hpp
boost/config/stdlib/roguewave.hpp
boost/config/stdlib/sgi.hpp
boost/config/stdlib/stlport.hpp
boost/config/stdlib/vacpp.hpp
boost/config/suffix.hpp
boost/config/warning_disable.hpp
boost/container/container_fwd.hpp [new file with mode: 0644]
boost/cstdint.hpp
boost/current_function.hpp
boost/detail/call_traits.hpp [deleted file]
boost/detail/endian.hpp
boost/detail/fenv.hpp [new file with mode: 0644]
boost/detail/indirect_traits.hpp [new file with mode: 0644]
boost/detail/interlocked.hpp
boost/detail/is_function_ref_tester.hpp [new file with mode: 0644]
boost/detail/limits.hpp [deleted file]
boost/detail/ob_call_traits.hpp [deleted file]
boost/detail/sp_typeinfo.hpp
boost/detail/templated_streams.hpp [new file with mode: 0644]
boost/exception/detail/attribute_noreturn.hpp
boost/exception/exception.hpp
boost/functional/hash/hash_fwd.hpp [new file with mode: 0644]
boost/functional/hash_fwd.hpp [new file with mode: 0644]
boost/fusion/adapted/mpl/detail/begin_impl.hpp [new file with mode: 0644]
boost/fusion/adapted/mpl/detail/end_impl.hpp [new file with mode: 0644]
boost/fusion/adapted/mpl/mpl_iterator.hpp [new file with mode: 0644]
boost/fusion/adapted/std_pair.hpp
boost/fusion/adapted/struct/adapt_struct.hpp
boost/fusion/adapted/struct/detail/adapt_base.hpp
boost/fusion/adapted/struct/detail/at_impl.hpp
boost/fusion/adapted/struct/detail/begin_impl.hpp
boost/fusion/adapted/struct/detail/category_of_impl.hpp
boost/fusion/adapted/struct/detail/deref_impl.hpp
boost/fusion/adapted/struct/detail/end_impl.hpp
boost/fusion/adapted/struct/detail/extension.hpp
boost/fusion/adapted/struct/detail/is_sequence_impl.hpp
boost/fusion/adapted/struct/detail/is_view_impl.hpp
boost/fusion/adapted/struct/detail/size_impl.hpp
boost/fusion/adapted/struct/detail/value_at_impl.hpp
boost/fusion/adapted/struct/detail/value_of_impl.hpp
boost/fusion/algorithm/transformation/push_back.hpp [new file with mode: 0644]
boost/fusion/algorithm/transformation/push_front.hpp [new file with mode: 0644]
boost/fusion/container/generation/ignore.hpp
boost/fusion/container/list/cons.hpp [new file with mode: 0644]
boost/fusion/container/list/cons_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/cons_iterator.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/at_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/begin_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/deref_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/empty_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/end_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/equal_to_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/next_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/preprocessed/list10_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/preprocessed/list20_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/preprocessed/list30_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/preprocessed/list40_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/preprocessed/list50_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/preprocessed/list_fwd.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/reverse_cons.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/value_at_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/detail/value_of_impl.hpp [new file with mode: 0644]
boost/fusion/container/list/limits.hpp [new file with mode: 0644]
boost/fusion/container/list/list_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/advance_impl.hpp
boost/fusion/container/vector/detail/at_impl.hpp
boost/fusion/container/vector/detail/begin_impl.hpp
boost/fusion/container/vector/detail/deref_impl.hpp
boost/fusion/container/vector/detail/distance_impl.hpp
boost/fusion/container/vector/detail/end_impl.hpp
boost/fusion/container/vector/detail/equal_to_impl.hpp
boost/fusion/container/vector/detail/next_impl.hpp
boost/fusion/container/vector/detail/preprocessed/vector.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector10.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector10_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector20.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector20_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector30.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector30_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector40.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector40_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector50.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector50_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_chooser.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_chooser10.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_chooser20.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_chooser30.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_chooser40.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_chooser50.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vector_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector10.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector10_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector20.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector20_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector30.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector30_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector40.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector40_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector50.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/preprocessed/vvector50_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/detail/prior_impl.hpp
boost/fusion/container/vector/detail/value_at_impl.hpp
boost/fusion/container/vector/detail/value_of_impl.hpp
boost/fusion/container/vector/detail/vector_forward_ctor.hpp
boost/fusion/container/vector/detail/vector_n.hpp
boost/fusion/container/vector/detail/vector_n_chooser.hpp
boost/fusion/container/vector/limits.hpp
boost/fusion/container/vector/vector.hpp
boost/fusion/container/vector/vector10.hpp
boost/fusion/container/vector/vector10_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/vector20.hpp
boost/fusion/container/vector/vector20_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/vector30.hpp
boost/fusion/container/vector/vector30_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/vector40.hpp
boost/fusion/container/vector/vector40_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/vector50.hpp
boost/fusion/container/vector/vector50_fwd.hpp [new file with mode: 0644]
boost/fusion/container/vector/vector_fwd.hpp
boost/fusion/container/vector/vector_iterator.hpp
boost/fusion/iterator/advance.hpp [new file with mode: 0644]
boost/fusion/iterator/deref.hpp
boost/fusion/iterator/deref_data.hpp [new file with mode: 0644]
boost/fusion/iterator/detail/adapt_deref_traits.hpp [new file with mode: 0644]
boost/fusion/iterator/detail/adapt_value_traits.hpp [new file with mode: 0644]
boost/fusion/iterator/detail/advance.hpp
boost/fusion/iterator/detail/distance.hpp
boost/fusion/iterator/detail/segment_sequence.hpp [new file with mode: 0644]
boost/fusion/iterator/detail/segmented_equal_to.hpp [new file with mode: 0644]
boost/fusion/iterator/detail/segmented_iterator.hpp [new file with mode: 0644]
boost/fusion/iterator/detail/segmented_next_impl.hpp [new file with mode: 0644]
boost/fusion/iterator/distance.hpp [new file with mode: 0644]
boost/fusion/iterator/equal_to.hpp
boost/fusion/iterator/iterator_facade.hpp
boost/fusion/iterator/key_of.hpp [new file with mode: 0644]
boost/fusion/iterator/mpl/convert_iterator.hpp [new file with mode: 0644]
boost/fusion/iterator/mpl/fusion_iterator.hpp [new file with mode: 0644]
boost/fusion/iterator/next.hpp
boost/fusion/iterator/prior.hpp
boost/fusion/iterator/segmented_iterator.hpp [new file with mode: 0644]
boost/fusion/iterator/value_of.hpp [new file with mode: 0644]
boost/fusion/iterator/value_of_data.hpp [new file with mode: 0644]
boost/fusion/mpl/begin.hpp [new file with mode: 0644]
boost/fusion/mpl/end.hpp [new file with mode: 0644]
boost/fusion/sequence/comparison.hpp
boost/fusion/sequence/comparison/detail/enable_comparison.hpp [deleted file]
boost/fusion/sequence/comparison/detail/equal_to.hpp
boost/fusion/sequence/comparison/detail/greater.hpp
boost/fusion/sequence/comparison/detail/greater_equal.hpp
boost/fusion/sequence/comparison/detail/less.hpp
boost/fusion/sequence/comparison/detail/less_equal.hpp
boost/fusion/sequence/comparison/detail/not_equal_to.hpp
boost/fusion/sequence/comparison/enable_comparison.hpp [new file with mode: 0644]
boost/fusion/sequence/comparison/equal_to.hpp
boost/fusion/sequence/comparison/greater.hpp
boost/fusion/sequence/comparison/greater_equal.hpp
boost/fusion/sequence/comparison/less.hpp
boost/fusion/sequence/comparison/less_equal.hpp
boost/fusion/sequence/comparison/not_equal_to.hpp
boost/fusion/sequence/intrinsic/at.hpp
boost/fusion/sequence/intrinsic/begin.hpp
boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/detail/segmented_end.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/detail/segmented_size.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/empty.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/end.hpp
boost/fusion/sequence/intrinsic/segments.hpp [new file with mode: 0644]
boost/fusion/sequence/intrinsic/size.hpp
boost/fusion/sequence/intrinsic/value_at.hpp
boost/fusion/sequence/intrinsic_fwd.hpp [new file with mode: 0644]
boost/fusion/sequence/io.hpp
boost/fusion/sequence/io/detail/in.hpp
boost/fusion/sequence/io/detail/manip.hpp
boost/fusion/sequence/io/detail/out.hpp
boost/fusion/sequence/io/in.hpp
boost/fusion/sequence/io/out.hpp
boost/fusion/support/as_const.hpp [new file with mode: 0644]
boost/fusion/support/category_of.hpp
boost/fusion/support/detail/access.hpp
boost/fusion/support/detail/as_fusion_element.hpp
boost/fusion/support/detail/category_of.hpp
boost/fusion/support/detail/is_mpl_sequence.hpp
boost/fusion/support/detail/is_view.hpp [new file with mode: 0644]
boost/fusion/support/detail/mpl_iterator_category.hpp [new file with mode: 0644]
boost/fusion/support/detail/pp_round.hpp [new file with mode: 0644]
boost/fusion/support/detail/segmented_fold_until_impl.hpp [new file with mode: 0644]
boost/fusion/support/is_iterator.hpp
boost/fusion/support/is_segmented.hpp [new file with mode: 0644]
boost/fusion/support/is_sequence.hpp
boost/fusion/support/is_view.hpp [new file with mode: 0644]
boost/fusion/support/iterator_base.hpp
boost/fusion/support/sequence_base.hpp
boost/fusion/support/tag_of.hpp
boost/fusion/support/tag_of_fwd.hpp
boost/fusion/support/void.hpp [new file with mode: 0644]
boost/fusion/tuple.hpp
boost/fusion/tuple/detail/preprocessed/make_tuple.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/make_tuple10.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/make_tuple20.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/make_tuple30.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/make_tuple40.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/make_tuple50.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple10.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple10_fwd.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple20.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple20_fwd.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple30.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple30_fwd.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple40.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple40_fwd.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple50.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple50_fwd.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_fwd.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_tie.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_tie10.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_tie20.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_tie30.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_tie40.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/preprocessed/tuple_tie50.hpp [new file with mode: 0644]
boost/fusion/tuple/detail/tuple_expand.hpp
boost/fusion/tuple/make_tuple.hpp
boost/fusion/tuple/tuple.hpp
boost/fusion/tuple/tuple_fwd.hpp
boost/fusion/tuple/tuple_tie.hpp
boost/fusion/view/iterator_range.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/at_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/begin_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/end_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/segments_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/size_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/detail/value_at_impl.hpp [new file with mode: 0644]
boost/fusion/view/iterator_range/iterator_range.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/begin_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/deref_data_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/deref_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/end_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/key_of_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/next_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/value_of_data_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/detail/value_of_impl.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/joint_view.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/joint_view_fwd.hpp [new file with mode: 0644]
boost/fusion/view/joint_view/joint_view_iterator.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/advance_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/at_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/begin_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/deref_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/distance_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/end_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/equal_to_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/next_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/prior_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/size_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/value_at_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/detail/value_of_impl.hpp [new file with mode: 0644]
boost/fusion/view/single_view/single_view.hpp [new file with mode: 0644]
boost/fusion/view/single_view/single_view_iterator.hpp [new file with mode: 0644]
boost/integer.hpp [new file with mode: 0644]
boost/integer/integer_mask.hpp [new file with mode: 0644]
boost/integer/static_log2.hpp [new file with mode: 0644]
boost/integer_fwd.hpp [new file with mode: 0644]
boost/integer_traits.hpp
boost/iterator.hpp [new file with mode: 0644]
boost/iterator/detail/config_def.hpp [new file with mode: 0644]
boost/iterator/detail/config_undef.hpp [new file with mode: 0644]
boost/iterator/detail/enable_if.hpp [new file with mode: 0644]
boost/iterator/detail/facade_iterator_category.hpp [new file with mode: 0644]
boost/iterator/interoperable.hpp [new file with mode: 0644]
boost/iterator/iterator_adaptor.hpp [new file with mode: 0644]
boost/iterator/iterator_categories.hpp [new file with mode: 0644]
boost/iterator/iterator_concepts.hpp [new file with mode: 0644]
boost/iterator/iterator_facade.hpp [new file with mode: 0644]
boost/iterator/iterator_traits.hpp [new file with mode: 0644]
boost/iterator/reverse_iterator.hpp [new file with mode: 0644]
boost/lexical_cast.hpp
boost/limits.hpp
boost/math/constants/calculate_constants.hpp [new file with mode: 0644]
boost/math/constants/constants.hpp
boost/math/distributions/complement.hpp
boost/math/distributions/detail/common_error_handling.hpp
boost/math/distributions/fwd.hpp
boost/math/distributions/normal.hpp
boost/math/policies/error_handling.hpp
boost/math/policies/policy.hpp
boost/math/special_functions.hpp [new file with mode: 0644]
boost/math/special_functions/acosh.hpp [new file with mode: 0644]
boost/math/special_functions/airy.hpp [new file with mode: 0644]
boost/math/special_functions/asinh.hpp [new file with mode: 0644]
boost/math/special_functions/atanh.hpp [new file with mode: 0644]
boost/math/special_functions/bessel.hpp [new file with mode: 0644]
boost/math/special_functions/beta.hpp [new file with mode: 0644]
boost/math/special_functions/binomial.hpp [new file with mode: 0644]
boost/math/special_functions/cbrt.hpp [new file with mode: 0644]
boost/math/special_functions/cos_pi.hpp [new file with mode: 0644]
boost/math/special_functions/detail/airy_ai_bi_zero.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_i0.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_i1.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_ik.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_j0.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_j1.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_jn.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_jy.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_jy_asym.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_jy_series.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_jy_zero.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_k0.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_k1.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_kn.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_y0.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_y1.hpp [new file with mode: 0644]
boost/math/special_functions/detail/bessel_yn.hpp [new file with mode: 0644]
boost/math/special_functions/detail/erf_inv.hpp
boost/math/special_functions/detail/fp_traits.hpp
boost/math/special_functions/detail/ibeta_inv_ab.hpp [new file with mode: 0644]
boost/math/special_functions/detail/ibeta_inverse.hpp [new file with mode: 0644]
boost/math/special_functions/detail/iconv.hpp [new file with mode: 0644]
boost/math/special_functions/detail/igamma_inverse.hpp
boost/math/special_functions/detail/igamma_large.hpp
boost/math/special_functions/detail/lanczos_sse2.hpp
boost/math/special_functions/detail/lgamma_small.hpp
boost/math/special_functions/detail/round_fwd.hpp
boost/math/special_functions/detail/t_distribution_inv.hpp [new file with mode: 0644]
boost/math/special_functions/detail/unchecked_factorial.hpp
boost/math/special_functions/digamma.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_1.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_2.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_3.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_rc.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_rd.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_rf.hpp [new file with mode: 0644]
boost/math/special_functions/ellint_rj.hpp [new file with mode: 0644]
boost/math/special_functions/erf.hpp
boost/math/special_functions/expint.hpp [new file with mode: 0644]
boost/math/special_functions/expm1.hpp
boost/math/special_functions/factorials.hpp [new file with mode: 0644]
boost/math/special_functions/fpclassify.hpp
boost/math/special_functions/gamma.hpp
boost/math/special_functions/hankel.hpp [new file with mode: 0644]
boost/math/special_functions/hermite.hpp [new file with mode: 0644]
boost/math/special_functions/hypot.hpp [new file with mode: 0644]
boost/math/special_functions/jacobi_elliptic.hpp [new file with mode: 0644]
boost/math/special_functions/laguerre.hpp [new file with mode: 0644]
boost/math/special_functions/lanczos.hpp
boost/math/special_functions/legendre.hpp [new file with mode: 0644]
boost/math/special_functions/log1p.hpp
boost/math/special_functions/math_fwd.hpp
boost/math/special_functions/modf.hpp [new file with mode: 0644]
boost/math/special_functions/next.hpp [new file with mode: 0644]
boost/math/special_functions/owens_t.hpp [new file with mode: 0644]
boost/math/special_functions/pow.hpp [new file with mode: 0644]
boost/math/special_functions/round.hpp [new file with mode: 0644]
boost/math/special_functions/sign.hpp
boost/math/special_functions/sin_pi.hpp [new file with mode: 0644]
boost/math/special_functions/sinc.hpp [new file with mode: 0644]
boost/math/special_functions/sinhc.hpp [new file with mode: 0644]
boost/math/special_functions/spherical_harmonic.hpp [new file with mode: 0644]
boost/math/special_functions/trunc.hpp
boost/math/special_functions/zeta.hpp [new file with mode: 0644]
boost/math/tools/big_constant.hpp [new file with mode: 0644]
boost/math/tools/config.hpp
boost/math/tools/detail/polynomial_horner1_10.hpp
boost/math/tools/detail/polynomial_horner1_11.hpp
boost/math/tools/detail/polynomial_horner1_12.hpp
boost/math/tools/detail/polynomial_horner1_13.hpp
boost/math/tools/detail/polynomial_horner1_14.hpp
boost/math/tools/detail/polynomial_horner1_15.hpp
boost/math/tools/detail/polynomial_horner1_16.hpp
boost/math/tools/detail/polynomial_horner1_17.hpp
boost/math/tools/detail/polynomial_horner1_18.hpp
boost/math/tools/detail/polynomial_horner1_19.hpp
boost/math/tools/detail/polynomial_horner1_2.hpp
boost/math/tools/detail/polynomial_horner1_20.hpp
boost/math/tools/detail/polynomial_horner1_3.hpp
boost/math/tools/detail/polynomial_horner1_4.hpp
boost/math/tools/detail/polynomial_horner1_5.hpp
boost/math/tools/detail/polynomial_horner1_6.hpp
boost/math/tools/detail/polynomial_horner1_7.hpp
boost/math/tools/detail/polynomial_horner1_8.hpp
boost/math/tools/detail/polynomial_horner1_9.hpp
boost/math/tools/detail/polynomial_horner2_10.hpp
boost/math/tools/detail/polynomial_horner2_11.hpp
boost/math/tools/detail/polynomial_horner2_12.hpp
boost/math/tools/detail/polynomial_horner2_13.hpp
boost/math/tools/detail/polynomial_horner2_14.hpp
boost/math/tools/detail/polynomial_horner2_15.hpp
boost/math/tools/detail/polynomial_horner2_16.hpp
boost/math/tools/detail/polynomial_horner2_17.hpp
boost/math/tools/detail/polynomial_horner2_18.hpp
boost/math/tools/detail/polynomial_horner2_19.hpp
boost/math/tools/detail/polynomial_horner2_2.hpp
boost/math/tools/detail/polynomial_horner2_20.hpp
boost/math/tools/detail/polynomial_horner2_3.hpp
boost/math/tools/detail/polynomial_horner2_4.hpp
boost/math/tools/detail/polynomial_horner2_5.hpp
boost/math/tools/detail/polynomial_horner2_6.hpp
boost/math/tools/detail/polynomial_horner2_7.hpp
boost/math/tools/detail/polynomial_horner2_8.hpp
boost/math/tools/detail/polynomial_horner2_9.hpp
boost/math/tools/detail/polynomial_horner3_10.hpp
boost/math/tools/detail/polynomial_horner3_11.hpp
boost/math/tools/detail/polynomial_horner3_12.hpp
boost/math/tools/detail/polynomial_horner3_13.hpp
boost/math/tools/detail/polynomial_horner3_14.hpp
boost/math/tools/detail/polynomial_horner3_15.hpp
boost/math/tools/detail/polynomial_horner3_16.hpp
boost/math/tools/detail/polynomial_horner3_17.hpp
boost/math/tools/detail/polynomial_horner3_18.hpp
boost/math/tools/detail/polynomial_horner3_19.hpp
boost/math/tools/detail/polynomial_horner3_2.hpp
boost/math/tools/detail/polynomial_horner3_20.hpp
boost/math/tools/detail/polynomial_horner3_3.hpp
boost/math/tools/detail/polynomial_horner3_4.hpp
boost/math/tools/detail/polynomial_horner3_5.hpp
boost/math/tools/detail/polynomial_horner3_6.hpp
boost/math/tools/detail/polynomial_horner3_7.hpp
boost/math/tools/detail/polynomial_horner3_8.hpp
boost/math/tools/detail/polynomial_horner3_9.hpp
boost/math/tools/detail/rational_horner2_10.hpp
boost/math/tools/detail/rational_horner2_11.hpp
boost/math/tools/detail/rational_horner2_12.hpp
boost/math/tools/detail/rational_horner2_13.hpp
boost/math/tools/detail/rational_horner2_14.hpp
boost/math/tools/detail/rational_horner2_15.hpp
boost/math/tools/detail/rational_horner2_16.hpp
boost/math/tools/detail/rational_horner2_17.hpp
boost/math/tools/detail/rational_horner2_18.hpp
boost/math/tools/detail/rational_horner2_19.hpp
boost/math/tools/detail/rational_horner2_2.hpp
boost/math/tools/detail/rational_horner2_20.hpp
boost/math/tools/detail/rational_horner2_3.hpp
boost/math/tools/detail/rational_horner2_4.hpp
boost/math/tools/detail/rational_horner2_5.hpp
boost/math/tools/detail/rational_horner2_6.hpp
boost/math/tools/detail/rational_horner2_7.hpp
boost/math/tools/detail/rational_horner2_8.hpp
boost/math/tools/detail/rational_horner2_9.hpp
boost/math/tools/detail/rational_horner3_10.hpp
boost/math/tools/detail/rational_horner3_11.hpp
boost/math/tools/detail/rational_horner3_12.hpp
boost/math/tools/detail/rational_horner3_13.hpp
boost/math/tools/detail/rational_horner3_14.hpp
boost/math/tools/detail/rational_horner3_15.hpp
boost/math/tools/detail/rational_horner3_16.hpp
boost/math/tools/detail/rational_horner3_17.hpp
boost/math/tools/detail/rational_horner3_18.hpp
boost/math/tools/detail/rational_horner3_19.hpp
boost/math/tools/detail/rational_horner3_2.hpp
boost/math/tools/detail/rational_horner3_20.hpp
boost/math/tools/detail/rational_horner3_3.hpp
boost/math/tools/detail/rational_horner3_4.hpp
boost/math/tools/detail/rational_horner3_5.hpp
boost/math/tools/detail/rational_horner3_6.hpp
boost/math/tools/detail/rational_horner3_7.hpp
boost/math/tools/detail/rational_horner3_8.hpp
boost/math/tools/detail/rational_horner3_9.hpp
boost/math/tools/fraction.hpp
boost/math/tools/precision.hpp
boost/math/tools/promotion.hpp
boost/math/tools/roots.hpp
boost/math/tools/toms748_solve.hpp
boost/math/tools/tuple.hpp [new file with mode: 0644]
boost/math/tools/workaround.hpp [new file with mode: 0644]
boost/mpl/O1_size.hpp
boost/mpl/O1_size_fwd.hpp
boost/mpl/advance.hpp
boost/mpl/advance_fwd.hpp
boost/mpl/always.hpp
boost/mpl/and.hpp
boost/mpl/apply.hpp
boost/mpl/apply_fwd.hpp
boost/mpl/apply_wrap.hpp
boost/mpl/arg.hpp
boost/mpl/arg_fwd.hpp
boost/mpl/assert.hpp
boost/mpl/at.hpp
boost/mpl/at_fwd.hpp
boost/mpl/aux_/O1_size_impl.hpp
boost/mpl/aux_/adl_barrier.hpp
boost/mpl/aux_/advance_backward.hpp
boost/mpl/aux_/advance_forward.hpp
boost/mpl/aux_/arg_typedef.hpp
boost/mpl/aux_/arithmetic_op.hpp
boost/mpl/aux_/arity.hpp
boost/mpl/aux_/arity_spec.hpp
boost/mpl/aux_/at_impl.hpp
boost/mpl/aux_/begin_end_impl.hpp
boost/mpl/aux_/clear_impl.hpp
boost/mpl/aux_/common_name_wknd.hpp
boost/mpl/aux_/comparison_op.hpp
boost/mpl/aux_/config/adl.hpp
boost/mpl/aux_/config/arrays.hpp
boost/mpl/aux_/config/bind.hpp
boost/mpl/aux_/config/compiler.hpp
boost/mpl/aux_/config/ctps.hpp
boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp
boost/mpl/aux_/config/dtp.hpp
boost/mpl/aux_/config/eti.hpp
boost/mpl/aux_/config/forwarding.hpp
boost/mpl/aux_/config/gcc.hpp
boost/mpl/aux_/config/has_apply.hpp
boost/mpl/aux_/config/has_xxx.hpp
boost/mpl/aux_/config/integral.hpp
boost/mpl/aux_/config/intel.hpp
boost/mpl/aux_/config/lambda.hpp
boost/mpl/aux_/config/msvc.hpp
boost/mpl/aux_/config/msvc_typename.hpp
boost/mpl/aux_/config/nttp.hpp
boost/mpl/aux_/config/overload_resolution.hpp
boost/mpl/aux_/config/pp_counter.hpp
boost/mpl/aux_/config/preprocessor.hpp
boost/mpl/aux_/config/static_constant.hpp
boost/mpl/aux_/config/ttp.hpp
boost/mpl/aux_/config/typeof.hpp
boost/mpl/aux_/config/use_preprocessed.hpp
boost/mpl/aux_/config/workaround.hpp
boost/mpl/aux_/contains_impl.hpp
boost/mpl/aux_/count_args.hpp
boost/mpl/aux_/fold_impl.hpp
boost/mpl/aux_/fold_impl_body.hpp
boost/mpl/aux_/full_lambda.hpp
boost/mpl/aux_/has_apply.hpp
boost/mpl/aux_/has_begin.hpp
boost/mpl/aux_/has_rebind.hpp
boost/mpl/aux_/has_size.hpp
boost/mpl/aux_/has_tag.hpp
boost/mpl/aux_/has_type.hpp
boost/mpl/aux_/include_preprocessed.hpp
boost/mpl/aux_/inserter_algorithm.hpp
boost/mpl/aux_/integral_wrapper.hpp
boost/mpl/aux_/is_msvc_eti_arg.hpp
boost/mpl/aux_/iter_apply.hpp
boost/mpl/aux_/iter_fold_if_impl.hpp
boost/mpl/aux_/iter_fold_impl.hpp
boost/mpl/aux_/lambda_arity_param.hpp
boost/mpl/aux_/lambda_no_ctps.hpp
boost/mpl/aux_/lambda_spec.hpp
boost/mpl/aux_/lambda_support.hpp
boost/mpl/aux_/largest_int.hpp
boost/mpl/aux_/logical_op.hpp
boost/mpl/aux_/msvc_dtw.hpp
boost/mpl/aux_/msvc_eti_base.hpp
boost/mpl/aux_/msvc_is_class.hpp
boost/mpl/aux_/msvc_never_true.hpp
boost/mpl/aux_/msvc_type.hpp
boost/mpl/aux_/na.hpp
boost/mpl/aux_/na_assert.hpp
boost/mpl/aux_/na_fwd.hpp
boost/mpl/aux_/na_spec.hpp
boost/mpl/aux_/nested_type_wknd.hpp
boost/mpl/aux_/nttp_decl.hpp
boost/mpl/aux_/numeric_cast_utils.hpp
boost/mpl/aux_/numeric_op.hpp
boost/mpl/aux_/preprocessor/add.hpp
boost/mpl/aux_/preprocessor/def_params_tail.hpp
boost/mpl/aux_/preprocessor/default_params.hpp
boost/mpl/aux_/preprocessor/enum.hpp
boost/mpl/aux_/preprocessor/ext_params.hpp
boost/mpl/aux_/preprocessor/filter_params.hpp
boost/mpl/aux_/preprocessor/params.hpp
boost/mpl/aux_/preprocessor/partial_spec_params.hpp
boost/mpl/aux_/preprocessor/range.hpp
boost/mpl/aux_/preprocessor/repeat.hpp
boost/mpl/aux_/preprocessor/sub.hpp
boost/mpl/aux_/preprocessor/tuple.hpp
boost/mpl/aux_/push_back_impl.hpp
boost/mpl/aux_/push_front_impl.hpp
boost/mpl/aux_/reverse_fold_impl.hpp
boost/mpl/aux_/reverse_fold_impl_body.hpp
boost/mpl/aux_/sequence_wrapper.hpp
boost/mpl/aux_/size_impl.hpp
boost/mpl/aux_/static_cast.hpp
boost/mpl/aux_/template_arity.hpp
boost/mpl/aux_/template_arity_fwd.hpp
boost/mpl/aux_/traits_lambda_spec.hpp
boost/mpl/aux_/type_wrapper.hpp
boost/mpl/aux_/value_wknd.hpp
boost/mpl/aux_/yes_no.hpp
boost/mpl/back_fwd.hpp
boost/mpl/back_inserter.hpp
boost/mpl/begin.hpp [new file with mode: 0644]
boost/mpl/begin_end.hpp
boost/mpl/begin_end_fwd.hpp
boost/mpl/bind.hpp
boost/mpl/bind_fwd.hpp
boost/mpl/bool.hpp
boost/mpl/bool_fwd.hpp
boost/mpl/clear.hpp
boost/mpl/clear_fwd.hpp
boost/mpl/comparison.hpp
boost/mpl/contains.hpp
boost/mpl/contains_fwd.hpp
boost/mpl/copy.hpp [new file with mode: 0644]
boost/mpl/deref.hpp
boost/mpl/distance.hpp
boost/mpl/distance_fwd.hpp
boost/mpl/divides.hpp [new file with mode: 0644]
boost/mpl/empty_base.hpp [new file with mode: 0644]
boost/mpl/empty_fwd.hpp
boost/mpl/end.hpp [new file with mode: 0644]
boost/mpl/equal_to.hpp
boost/mpl/eval_if.hpp
boost/mpl/find.hpp
boost/mpl/find_if.hpp
boost/mpl/fold.hpp
boost/mpl/front_fwd.hpp
boost/mpl/front_inserter.hpp
boost/mpl/greater.hpp
boost/mpl/greater_equal.hpp
boost/mpl/has_xxx.hpp
boost/mpl/identity.hpp
boost/mpl/if.hpp
boost/mpl/inherit.hpp [new file with mode: 0644]
boost/mpl/inserter.hpp
boost/mpl/int.hpp
boost/mpl/int_fwd.hpp
boost/mpl/integral_c.hpp
boost/mpl/integral_c_fwd.hpp
boost/mpl/integral_c_tag.hpp
boost/mpl/is_placeholder.hpp
boost/mpl/is_sequence.hpp
boost/mpl/iter_fold.hpp
boost/mpl/iter_fold_if.hpp
boost/mpl/iterator_range.hpp
boost/mpl/iterator_tags.hpp
boost/mpl/lambda.hpp
boost/mpl/lambda_fwd.hpp
boost/mpl/less.hpp
boost/mpl/less_equal.hpp
boost/mpl/limits/arity.hpp
boost/mpl/limits/list.hpp
boost/mpl/limits/unrolling.hpp
boost/mpl/limits/vector.hpp
boost/mpl/list.hpp
boost/mpl/list/aux_/O1_size.hpp
boost/mpl/list/aux_/begin_end.hpp
boost/mpl/list/aux_/clear.hpp
boost/mpl/list/aux_/empty.hpp
boost/mpl/list/aux_/front.hpp
boost/mpl/list/aux_/include_preprocessed.hpp
boost/mpl/list/aux_/item.hpp
boost/mpl/list/aux_/iterator.hpp
boost/mpl/list/aux_/numbered.hpp
boost/mpl/list/aux_/numbered_c.hpp
boost/mpl/list/aux_/pop_front.hpp
boost/mpl/list/aux_/push_back.hpp
boost/mpl/list/aux_/push_front.hpp
boost/mpl/list/aux_/size.hpp
boost/mpl/list/aux_/tag.hpp
boost/mpl/list/list0.hpp
boost/mpl/list/list0_c.hpp
boost/mpl/list/list10.hpp
boost/mpl/list/list10_c.hpp
boost/mpl/list/list20.hpp
boost/mpl/list/list20_c.hpp
boost/mpl/list/list30.hpp
boost/mpl/list/list30_c.hpp
boost/mpl/list/list40.hpp
boost/mpl/list/list40_c.hpp
boost/mpl/list/list50.hpp
boost/mpl/list/list50_c.hpp
boost/mpl/logical.hpp
boost/mpl/long.hpp
boost/mpl/long_fwd.hpp
boost/mpl/minus.hpp
boost/mpl/multiplies.hpp
boost/mpl/negate.hpp
boost/mpl/next.hpp
boost/mpl/next_prior.hpp
boost/mpl/not.hpp
boost/mpl/not_equal_to.hpp
boost/mpl/numeric_cast.hpp
boost/mpl/or.hpp
boost/mpl/pair.hpp
boost/mpl/placeholders.hpp
boost/mpl/plus.hpp
boost/mpl/pop_back_fwd.hpp
boost/mpl/pop_front_fwd.hpp
boost/mpl/prior.hpp
boost/mpl/protect.hpp
boost/mpl/push_back.hpp
boost/mpl/push_back_fwd.hpp
boost/mpl/push_front.hpp
boost/mpl/push_front_fwd.hpp
boost/mpl/quote.hpp
boost/mpl/remove_if.hpp
boost/mpl/reverse_fold.hpp
boost/mpl/same_as.hpp
boost/mpl/sequence_tag.hpp
boost/mpl/sequence_tag_fwd.hpp
boost/mpl/size.hpp
boost/mpl/size_fwd.hpp
boost/mpl/size_t.hpp
boost/mpl/size_t_fwd.hpp
boost/mpl/tag.hpp
boost/mpl/times.hpp
boost/mpl/vector.hpp
boost/mpl/vector/aux_/O1_size.hpp
boost/mpl/vector/aux_/at.hpp
boost/mpl/vector/aux_/back.hpp
boost/mpl/vector/aux_/begin_end.hpp
boost/mpl/vector/aux_/clear.hpp
boost/mpl/vector/aux_/empty.hpp
boost/mpl/vector/aux_/front.hpp
boost/mpl/vector/aux_/include_preprocessed.hpp
boost/mpl/vector/aux_/item.hpp
boost/mpl/vector/aux_/iterator.hpp
boost/mpl/vector/aux_/numbered.hpp
boost/mpl/vector/aux_/numbered_c.hpp
boost/mpl/vector/aux_/pop_back.hpp
boost/mpl/vector/aux_/pop_front.hpp
boost/mpl/vector/aux_/push_back.hpp
boost/mpl/vector/aux_/push_front.hpp
boost/mpl/vector/aux_/size.hpp
boost/mpl/vector/aux_/tag.hpp
boost/mpl/vector/aux_/vector0.hpp
boost/mpl/vector/vector0.hpp
boost/mpl/vector/vector0_c.hpp
boost/mpl/vector/vector10.hpp
boost/mpl/vector/vector10_c.hpp
boost/mpl/vector/vector20.hpp
boost/mpl/vector/vector20_c.hpp
boost/mpl/vector/vector30.hpp
boost/mpl/vector/vector30_c.hpp
boost/mpl/vector/vector40.hpp
boost/mpl/vector/vector40_c.hpp
boost/mpl/vector/vector50.hpp
boost/mpl/vector/vector50_c.hpp
boost/mpl/void.hpp
boost/mpl/void_fwd.hpp
boost/next_prior.hpp [new file with mode: 0644]
boost/noncopyable.hpp [new file with mode: 0644]
boost/none.hpp
boost/numeric/conversion/bounds.hpp [new file with mode: 0644]
boost/numeric/conversion/cast.hpp [new file with mode: 0644]
boost/numeric/conversion/conversion_traits.hpp [new file with mode: 0644]
boost/numeric/conversion/converter.hpp [new file with mode: 0644]
boost/numeric/conversion/converter_policies.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/bounds.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/conversion_traits.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/converter.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/int_float_mixture.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/is_subranged.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/meta.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/numeric_cast_traits.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/old_numeric_cast.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/sign_mixture.hpp [new file with mode: 0644]
boost/numeric/conversion/detail/udt_builtin_mixture.hpp [new file with mode: 0644]
boost/numeric/conversion/int_float_mixture_enum.hpp [new file with mode: 0644]
boost/numeric/conversion/numeric_cast_traits.hpp [new file with mode: 0644]
boost/numeric/conversion/sign_mixture_enum.hpp [new file with mode: 0644]
boost/numeric/conversion/udt_builtin_mixture_enum.hpp [new file with mode: 0644]
boost/optional/optional.hpp
boost/optional/optional_fwd.hpp
boost/pending/integer_log2.hpp [new file with mode: 0644]
boost/predef/architecture.h [new file with mode: 0644]
boost/predef/architecture/alpha.h [new file with mode: 0644]
boost/predef/architecture/arm.h [new file with mode: 0644]
boost/predef/architecture/blackfin.h [new file with mode: 0644]
boost/predef/architecture/convex.h [new file with mode: 0644]
boost/predef/architecture/ia64.h [new file with mode: 0644]
boost/predef/architecture/m68k.h [new file with mode: 0644]
boost/predef/architecture/mips.h [new file with mode: 0644]
boost/predef/architecture/parisc.h [new file with mode: 0644]
boost/predef/architecture/ppc.h [new file with mode: 0644]
boost/predef/architecture/pyramid.h [new file with mode: 0644]
boost/predef/architecture/rs6k.h [new file with mode: 0644]
boost/predef/architecture/sparc.h [new file with mode: 0644]
boost/predef/architecture/superh.h [new file with mode: 0644]
boost/predef/architecture/sys370.h [new file with mode: 0644]
boost/predef/architecture/sys390.h [new file with mode: 0644]
boost/predef/architecture/x86.h [new file with mode: 0644]
boost/predef/architecture/x86/32.h [new file with mode: 0644]
boost/predef/architecture/x86/64.h [new file with mode: 0644]
boost/predef/architecture/z.h [new file with mode: 0644]
boost/predef/detail/_cassert.h [new file with mode: 0644]
boost/predef/detail/endian_compat.h [new file with mode: 0644]
boost/predef/detail/os_detected.h [new file with mode: 0644]
boost/predef/detail/test.h [new file with mode: 0644]
boost/predef/library/c/_prefix.h [new file with mode: 0644]
boost/predef/library/c/gnu.h [new file with mode: 0644]
boost/predef/make.h [new file with mode: 0644]
boost/predef/os/bsd.h [new file with mode: 0644]
boost/predef/os/bsd/bsdi.h [new file with mode: 0644]
boost/predef/os/bsd/dragonfly.h [new file with mode: 0644]
boost/predef/os/bsd/free.h [new file with mode: 0644]
boost/predef/os/bsd/net.h [new file with mode: 0644]
boost/predef/os/bsd/open.h [new file with mode: 0644]
boost/predef/os/macos.h [new file with mode: 0644]
boost/predef/os/windows.h [new file with mode: 0644]
boost/predef/other/endian.h [new file with mode: 0644]
boost/predef/version_number.h [new file with mode: 0644]
boost/preprocessor/cat.hpp
boost/preprocessor/comparison/less.hpp [new file with mode: 0644]
boost/preprocessor/comparison/less_equal.hpp [new file with mode: 0644]
boost/preprocessor/comparison/not_equal.hpp [new file with mode: 0644]
boost/preprocessor/config/config.hpp
boost/preprocessor/detail/is_unary.hpp [new file with mode: 0644]
boost/preprocessor/facilities/overload.hpp [new file with mode: 0644]
boost/preprocessor/if.hpp [new file with mode: 0644]
boost/preprocessor/iteration/detail/iter/forward1.hpp
boost/preprocessor/iteration/detail/iter/forward2.hpp
boost/preprocessor/iteration/detail/iter/forward3.hpp
boost/preprocessor/iteration/detail/iter/forward4.hpp
boost/preprocessor/iteration/detail/iter/forward5.hpp
boost/preprocessor/iteration/iterate.hpp
boost/preprocessor/logical/bitor.hpp [new file with mode: 0644]
boost/preprocessor/logical/not.hpp [new file with mode: 0644]
boost/preprocessor/logical/or.hpp [new file with mode: 0644]
boost/preprocessor/punctuation/paren.hpp [new file with mode: 0644]
boost/preprocessor/repeat_from_to.hpp [new file with mode: 0644]
boost/preprocessor/repetition/enum_trailing.hpp [new file with mode: 0644]
boost/preprocessor/seq/cat.hpp [new file with mode: 0644]
boost/preprocessor/seq/size.hpp
boost/preprocessor/seq/transform.hpp [new file with mode: 0644]
boost/preprocessor/tuple/eat.hpp
boost/preprocessor/tuple/elem.hpp
boost/preprocessor/tuple/rem.hpp
boost/preprocessor/tuple/to_list.hpp
boost/preprocessor/variadic/elem.hpp [new file with mode: 0644]
boost/preprocessor/variadic/size.hpp [new file with mode: 0644]
boost/random.hpp
boost/random/additive_combine.hpp
boost/random/bernoulli_distribution.hpp
boost/random/binomial_distribution.hpp
boost/random/cauchy_distribution.hpp
boost/random/chi_squared_distribution.hpp [new file with mode: 0644]
boost/random/detail/const_mod.hpp
boost/random/detail/generator_bits.hpp [new file with mode: 0644]
boost/random/detail/generator_seed_seq.hpp [new file with mode: 0644]
boost/random/detail/integer_log2.hpp [new file with mode: 0644]
boost/random/detail/large_arithmetic.hpp [new file with mode: 0644]
boost/random/detail/operators.hpp [new file with mode: 0644]
boost/random/detail/pass_through_engine.hpp [deleted file]
boost/random/detail/seed.hpp
boost/random/detail/seed_impl.hpp [new file with mode: 0644]
boost/random/detail/signed_unsigned_tools.hpp
boost/random/detail/uniform_int_float.hpp
boost/random/detail/vector_io.hpp [new file with mode: 0644]
boost/random/discard_block.hpp
boost/random/discrete_distribution.hpp [new file with mode: 0644]
boost/random/exponential_distribution.hpp
boost/random/extreme_value_distribution.hpp [new file with mode: 0644]
boost/random/fisher_f_distribution.hpp [new file with mode: 0644]
boost/random/gamma_distribution.hpp
boost/random/generate_canonical.hpp [new file with mode: 0644]
boost/random/geometric_distribution.hpp
boost/random/independent_bits.hpp [new file with mode: 0644]
boost/random/inversive_congruential.hpp
boost/random/lagged_fibonacci.hpp
boost/random/linear_congruential.hpp
boost/random/linear_feedback_shift.hpp
boost/random/lognormal_distribution.hpp
boost/random/mersenne_twister.hpp
boost/random/negative_binomial_distribution.hpp [new file with mode: 0644]
boost/random/normal_distribution.hpp
boost/random/piecewise_constant_distribution.hpp [new file with mode: 0644]
boost/random/piecewise_linear_distribution.hpp [new file with mode: 0644]
boost/random/poisson_distribution.hpp
boost/random/random_number_generator.hpp
boost/random/ranlux.hpp
boost/random/seed_seq.hpp [new file with mode: 0644]
boost/random/shuffle_order.hpp [new file with mode: 0644]
boost/random/shuffle_output.hpp
boost/random/student_t_distribution.hpp [new file with mode: 0644]
boost/random/subtract_with_carry.hpp
boost/random/taus88.hpp [new file with mode: 0644]
boost/random/triangle_distribution.hpp
boost/random/uniform_01.hpp
boost/random/uniform_int.hpp
boost/random/uniform_int_distribution.hpp [new file with mode: 0644]
boost/random/uniform_on_sphere.hpp
boost/random/uniform_real.hpp
boost/random/uniform_real_distribution.hpp [new file with mode: 0644]
boost/random/uniform_smallint.hpp
boost/random/variate_generator.hpp
boost/random/weibull_distribution.hpp [new file with mode: 0644]
boost/random/xor_combine.hpp
boost/range/algorithm/equal.hpp [new file with mode: 0644]
boost/range/begin.hpp [new file with mode: 0644]
boost/range/concepts.hpp [new file with mode: 0644]
boost/range/config.hpp [new file with mode: 0644]
boost/range/const_iterator.hpp [new file with mode: 0644]
boost/range/detail/begin.hpp [new file with mode: 0644]
boost/range/detail/common.hpp [new file with mode: 0644]
boost/range/detail/const_iterator.hpp [new file with mode: 0644]
boost/range/detail/end.hpp [new file with mode: 0644]
boost/range/detail/extract_optional_type.hpp [new file with mode: 0644]
boost/range/detail/implementation_help.hpp [new file with mode: 0644]
boost/range/detail/iterator.hpp [new file with mode: 0644]
boost/range/detail/misc_concept.hpp [new file with mode: 0644]
boost/range/detail/remove_extent.hpp [new file with mode: 0644]
boost/range/detail/safe_bool.hpp [new file with mode: 0644]
boost/range/detail/sfinae.hpp [new file with mode: 0644]
boost/range/detail/size_type.hpp [new file with mode: 0644]
boost/range/detail/vc6/end.hpp [new file with mode: 0644]
boost/range/difference_type.hpp [new file with mode: 0644]
boost/range/distance.hpp [new file with mode: 0644]
boost/range/empty.hpp [new file with mode: 0644]
boost/range/end.hpp [new file with mode: 0644]
boost/range/functions.hpp [new file with mode: 0644]
boost/range/iterator.hpp [new file with mode: 0644]
boost/range/iterator_range_core.hpp [new file with mode: 0644]
boost/range/mutable_iterator.hpp [new file with mode: 0644]
boost/range/rbegin.hpp [new file with mode: 0644]
boost/range/rend.hpp [new file with mode: 0644]
boost/range/result_iterator.hpp [new file with mode: 0644]
boost/range/reverse_iterator.hpp [new file with mode: 0644]
boost/range/size.hpp [new file with mode: 0644]
boost/range/size_type.hpp [new file with mode: 0644]
boost/range/value_type.hpp [new file with mode: 0644]
boost/smart_ptr/detail/operator_bool.hpp
boost/smart_ptr/detail/shared_count.hpp
boost/smart_ptr/detail/sp_convertible.hpp
boost/smart_ptr/detail/sp_counted_base.hpp
boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
boost/smart_ptr/detail/sp_counted_base_aix.hpp [new file with mode: 0644]
boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
boost/smart_ptr/detail/sp_counted_base_nt.hpp
boost/smart_ptr/detail/sp_counted_base_pt.hpp
boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp [new file with mode: 0644]
boost/smart_ptr/detail/sp_counted_base_spin.hpp
boost/smart_ptr/detail/sp_counted_base_sync.hpp
boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp [new file with mode: 0644]
boost/smart_ptr/detail/sp_counted_base_w32.hpp
boost/smart_ptr/detail/sp_counted_impl.hpp
boost/smart_ptr/detail/sp_has_sync.hpp
boost/smart_ptr/detail/sp_nullptr_t.hpp [new file with mode: 0644]
boost/smart_ptr/detail/spinlock.hpp
boost/smart_ptr/detail/spinlock_gcc_arm.hpp
boost/smart_ptr/detail/spinlock_pool.hpp
boost/smart_ptr/detail/yield_k.hpp
boost/smart_ptr/shared_ptr.hpp
boost/static_assert.hpp
boost/throw_exception.hpp
boost/tr1/detail/config_all.hpp
boost/tuple/detail/tuple_basic.hpp
boost/tuple/detail/tuple_basic_no_partial_spec.hpp
boost/type_traits.hpp
boost/type_traits/add_lvalue_reference.hpp [new file with mode: 0644]
boost/type_traits/add_reference.hpp
boost/type_traits/add_rvalue_reference.hpp [new file with mode: 0644]
boost/type_traits/alignment_of.hpp
boost/type_traits/arithmetic_traits.hpp [deleted file]
boost/type_traits/common_type.hpp [new file with mode: 0644]
boost/type_traits/composite_traits.hpp [deleted file]
boost/type_traits/conditional.hpp [new file with mode: 0644]
boost/type_traits/config.hpp
boost/type_traits/conversion_traits.hpp [new file with mode: 0644]
boost/type_traits/detail/bool_trait_def.hpp
boost/type_traits/detail/bool_trait_undef.hpp
boost/type_traits/detail/common_type_imp.hpp [new file with mode: 0644]
boost/type_traits/detail/cv_traits_impl.hpp
boost/type_traits/detail/has_binary_operator.hpp [new file with mode: 0644]
boost/type_traits/detail/has_postfix_operator.hpp [new file with mode: 0644]
boost/type_traits/detail/has_prefix_operator.hpp [new file with mode: 0644]
boost/type_traits/detail/is_function_ptr_tester.hpp
boost/type_traits/detail/size_t_trait_def.hpp
boost/type_traits/detail/size_t_trait_undef.hpp
boost/type_traits/detail/type_trait_def.hpp
boost/type_traits/detail/type_trait_undef.hpp
boost/type_traits/function_traits.hpp
boost/type_traits/has_bit_and.hpp [new file with mode: 0644]
boost/type_traits/has_bit_and_assign.hpp [new file with mode: 0644]
boost/type_traits/has_bit_or.hpp [new file with mode: 0644]
boost/type_traits/has_bit_or_assign.hpp [new file with mode: 0644]
boost/type_traits/has_bit_xor.hpp [new file with mode: 0644]
boost/type_traits/has_bit_xor_assign.hpp [new file with mode: 0644]
boost/type_traits/has_complement.hpp [new file with mode: 0644]
boost/type_traits/has_dereference.hpp [new file with mode: 0644]
boost/type_traits/has_divides.hpp [new file with mode: 0644]
boost/type_traits/has_divides_assign.hpp [new file with mode: 0644]
boost/type_traits/has_equal_to.hpp [new file with mode: 0644]
boost/type_traits/has_greater.hpp [new file with mode: 0644]
boost/type_traits/has_greater_equal.hpp [new file with mode: 0644]
boost/type_traits/has_left_shift.hpp [new file with mode: 0644]
boost/type_traits/has_left_shift_assign.hpp [new file with mode: 0644]
boost/type_traits/has_less.hpp [new file with mode: 0644]
boost/type_traits/has_less_equal.hpp [new file with mode: 0644]
boost/type_traits/has_logical_and.hpp [new file with mode: 0644]
boost/type_traits/has_logical_not.hpp [new file with mode: 0644]
boost/type_traits/has_logical_or.hpp [new file with mode: 0644]
boost/type_traits/has_minus.hpp [new file with mode: 0644]
boost/type_traits/has_minus_assign.hpp [new file with mode: 0644]
boost/type_traits/has_modulus.hpp [new file with mode: 0644]
boost/type_traits/has_modulus_assign.hpp [new file with mode: 0644]
boost/type_traits/has_multiplies.hpp [new file with mode: 0644]
boost/type_traits/has_multiplies_assign.hpp [new file with mode: 0644]
boost/type_traits/has_negate.hpp [new file with mode: 0644]
boost/type_traits/has_not_equal_to.hpp [new file with mode: 0644]
boost/type_traits/has_nothrow_assign.hpp
boost/type_traits/has_nothrow_constructor.hpp
boost/type_traits/has_nothrow_copy.hpp
boost/type_traits/has_operator.hpp [new file with mode: 0644]
boost/type_traits/has_plus.hpp [new file with mode: 0644]
boost/type_traits/has_plus_assign.hpp [new file with mode: 0644]
boost/type_traits/has_post_decrement.hpp [new file with mode: 0644]
boost/type_traits/has_post_increment.hpp [new file with mode: 0644]
boost/type_traits/has_pre_decrement.hpp [new file with mode: 0644]
boost/type_traits/has_pre_increment.hpp [new file with mode: 0644]
boost/type_traits/has_right_shift.hpp [new file with mode: 0644]
boost/type_traits/has_right_shift_assign.hpp [new file with mode: 0644]
boost/type_traits/has_trivial_assign.hpp
boost/type_traits/has_trivial_constructor.hpp
boost/type_traits/has_trivial_copy.hpp
boost/type_traits/has_trivial_destructor.hpp
boost/type_traits/has_trivial_move_assign.hpp [new file with mode: 0644]
boost/type_traits/has_trivial_move_constructor.hpp [new file with mode: 0644]
boost/type_traits/has_unary_minus.hpp [new file with mode: 0644]
boost/type_traits/has_unary_plus.hpp [new file with mode: 0644]
boost/type_traits/has_virtual_destructor.hpp
boost/type_traits/integral_promotion.hpp
boost/type_traits/intrinsics.hpp
boost/type_traits/is_abstract.hpp
boost/type_traits/is_array.hpp
boost/type_traits/is_const.hpp
boost/type_traits/is_convertible.hpp
boost/type_traits/is_copy_constructible.hpp [new file with mode: 0644]
boost/type_traits/is_empty.hpp
boost/type_traits/is_enum.hpp
boost/type_traits/is_function.hpp
boost/type_traits/is_fundamental.hpp
boost/type_traits/is_integral.hpp
boost/type_traits/is_member_function_pointer.hpp
boost/type_traits/is_member_pointer.hpp
boost/type_traits/is_nothrow_move_assignable.hpp [new file with mode: 0644]
boost/type_traits/is_nothrow_move_constructible.hpp [new file with mode: 0644]
boost/type_traits/is_pod.hpp
boost/type_traits/is_pointer.hpp
boost/type_traits/is_rvalue_reference.hpp
boost/type_traits/is_signed.hpp
boost/type_traits/is_union.hpp
boost/type_traits/is_unsigned.hpp
boost/type_traits/is_virtual_base_of.hpp
boost/type_traits/is_volatile.hpp
boost/type_traits/make_signed.hpp
boost/type_traits/make_unsigned.hpp
boost/type_traits/msvc/typeof.hpp
boost/type_traits/promote.hpp
boost/type_traits/remove_const.hpp
boost/type_traits/remove_cv.hpp
boost/type_traits/remove_pointer.hpp
boost/type_traits/remove_reference.hpp
boost/type_traits/remove_volatile.hpp
boost/type_traits/type_with_alignment.hpp
boost/typeof/dmc/typeof_impl.hpp [new file with mode: 0644]
boost/typeof/encode_decode.hpp [new file with mode: 0644]
boost/typeof/encode_decode_params.hpp [new file with mode: 0644]
boost/typeof/int_encoding.hpp [new file with mode: 0644]
boost/typeof/integral_template_param.hpp [new file with mode: 0644]
boost/typeof/message.hpp [new file with mode: 0644]
boost/typeof/modifiers.hpp [new file with mode: 0644]
boost/typeof/msvc/typeof_impl.hpp [new file with mode: 0644]
boost/typeof/native.hpp [new file with mode: 0644]
boost/typeof/pointers_data_members.hpp [new file with mode: 0644]
boost/typeof/register_functions.hpp [new file with mode: 0644]
boost/typeof/register_functions_iterate.hpp [new file with mode: 0644]
boost/typeof/register_fundamental.hpp [new file with mode: 0644]
boost/typeof/register_mem_functions.hpp [new file with mode: 0644]
boost/typeof/template_encoding.hpp [new file with mode: 0644]
boost/typeof/template_template_param.hpp [new file with mode: 0644]
boost/typeof/type_encoding.hpp [new file with mode: 0644]
boost/typeof/type_template_param.hpp [new file with mode: 0644]
boost/typeof/typeof.hpp [new file with mode: 0644]
boost/typeof/typeof_impl.hpp [new file with mode: 0644]
boost/typeof/unsupported.hpp [new file with mode: 0644]
boost/typeof/vector.hpp [new file with mode: 0644]
boost/typeof/vector100.hpp [new file with mode: 0644]
boost/typeof/vector150.hpp [new file with mode: 0644]
boost/typeof/vector200.hpp [new file with mode: 0644]
boost/typeof/vector50.hpp [new file with mode: 0644]
boost/utility/addressof.hpp
boost/utility/base_from_member.hpp
boost/utility/declval.hpp [new file with mode: 0644]
boost/utility/detail/in_place_factory_prefix.hpp [new file with mode: 0644]
boost/utility/detail/in_place_factory_suffix.hpp [new file with mode: 0644]
boost/utility/detail/result_of_iterate.hpp [new file with mode: 0644]
boost/utility/in_place_factory.hpp [new file with mode: 0644]
boost/utility/result_of.hpp [new file with mode: 0644]
boost/version.hpp

index 7df2771..fa06fa9 100644 (file)
@@ -13,6 +13,8 @@
  * accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
+ * 14 Apr 2012 - (mtc) Added support for boost::hash
+ * 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility.
  * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
  *      See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168
  *      Eventually, we should remove "assign" which is now a synonym for "fill" (Marshall Clow)
@@ -45,6 +47,7 @@
 // Handles broken standard libraries better than <iterator>
 #include <boost/detail/iterator.hpp>
 #include <boost/throw_exception.hpp>
+#include <boost/functional/hash_fwd.hpp>
 #include <algorithm>
 
 // FIXES for broken compilers
@@ -69,10 +72,13 @@ namespace boost {
         typedef std::ptrdiff_t difference_type;
 
         // iterator support
-        iterator begin() { return elems; }
-        const_iterator begin() const { return elems; }
-        iterator end() { return elems+N; }
-        const_iterator end() const { return elems+N; }
+        iterator        begin()       { return elems; }
+        const_iterator  begin() const { return elems; }
+        const_iterator cbegin() const { return elems; }
+        
+        iterator        end()       { return elems+N; }
+        const_iterator  end() const { return elems+N; }
+        const_iterator cend() const { return elems+N; }
 
         // reverse iterator support
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
@@ -99,21 +105,28 @@ namespace boost {
         const_reverse_iterator rbegin() const {
             return const_reverse_iterator(end());
         }
+        const_reverse_iterator crbegin() const {
+            return const_reverse_iterator(end());
+        }
+
         reverse_iterator rend() { return reverse_iterator(begin()); }
         const_reverse_iterator rend() const {
             return const_reverse_iterator(begin());
         }
+        const_reverse_iterator crend() const {
+            return const_reverse_iterator(begin());
+        }
 
         // operator[]
         reference operator[](size_type i) 
         { 
-            BOOST_ASSERT( i < N && "out of range" ); 
+            BOOST_ASSERT_MSG( i < N, "out of range" );
             return elems[i];
         }
         
         const_reference operator[](size_type i) const 
         {     
-            BOOST_ASSERT( i < N && "out of range" ); 
+            BOOST_ASSERT_MSG( i < N, "out of range" );
             return elems[i]; 
         }
 
@@ -200,10 +213,13 @@ namespace boost {
         typedef std::ptrdiff_t difference_type;
 
         // iterator support
-        iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
-        const_iterator begin() const { return const_iterator(  reinterpret_cast< const T * >( this ) ); }
-        iterator end() { return begin(); }
-        const_iterator end() const { return begin(); }
+        iterator        begin()       { return       iterator( reinterpret_cast<       T * >( this ) ); }
+        const_iterator  begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
+        const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
+
+        iterator        end()       { return  begin(); }
+        const_iterator  end() const { return  begin(); }
+        const_iterator cend() const { return cbegin(); }
 
         // reverse iterator support
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
@@ -230,10 +246,17 @@ namespace boost {
         const_reverse_iterator rbegin() const {
             return const_reverse_iterator(end());
         }
+        const_reverse_iterator crbegin() const {
+            return const_reverse_iterator(end());
+        }
+
         reverse_iterator rend() { return reverse_iterator(begin()); }
         const_reverse_iterator rend() const {
             return const_reverse_iterator(begin());
         }
+        const_reverse_iterator crend() const {
+            return const_reverse_iterator(begin());
+        }
 
         // operator[]
         reference operator[](size_type /*i*/)
@@ -301,7 +324,7 @@ namespace boost {
         static reference failed_rangecheck () {
                 std::out_of_range e("attempt to access element of an empty array");
                 boost::throw_exception(e);
-#if defined(BOOST_NO_EXCEPTIONS) || !defined(BOOST_MSVC)
+#if defined(BOOST_NO_EXCEPTIONS) || (!defined(BOOST_MSVC) && !defined(__PATHSCALE__))
                 //
                 // We need to return something here to keep
                 // some compilers happy: however we will never
@@ -346,7 +369,34 @@ namespace boost {
         x.swap(y);
     }
 
-    // Specific for boost::array: simply returns its elems data member.
+#if defined(__SUNPRO_CC)
+//  Trac ticket #4757; the Sun Solaris compiler can't handle
+//  syntax like 'T(&get_c_array(boost::array<T,N>& arg))[N]'
+//  
+//  We can't just use this for all compilers, because the 
+//      borland compilers can't handle this form. 
+    namespace detail {
+       template <typename T, std::size_t N> struct c_array
+       {
+           typedef T type[N];
+       };
+    }
+    
+   // Specific for boost::array: simply returns its elems data member.
+   template <typename T, std::size_t N>
+   typename detail::c_array<T,N>::type& get_c_array(boost::array<T,N>& arg)
+   {
+       return arg.elems;
+   }
+
+   // Specific for boost::array: simply returns its elems data member.
+   template <typename T, std::size_t N>
+   typename const detail::c_array<T,N>::type& get_c_array(const boost::array<T,N>& arg)
+   {
+       return arg.elems;
+   }
+#else
+// Specific for boost::array: simply returns its elems data member.
     template <typename T, std::size_t N>
     T(&get_c_array(boost::array<T,N>& arg))[N]
     {
@@ -359,7 +409,8 @@ namespace boost {
     {
         return arg.elems;
     }
-
+#endif
+    
 #if 0
     // Overload for std::array, assuming that std::array will have
     // explicit conversion functions as discussed at the WG21 meeting
@@ -378,6 +429,13 @@ namespace boost {
     }
 #endif
 
+
+    template<class T, std::size_t N>
+    std::size_t hash_value(const array<T,N>& arr)
+    {
+        return boost::hash_range(arr.begin(), arr.end());
+    }
+
 } /* namespace boost */
 
 
index c227f17..ccc776a 100644 (file)
@@ -1,8 +1,11 @@
 //
 //  boost/assert.hpp - BOOST_ASSERT(expr)
+//                     BOOST_ASSERT_MSG(expr, msg)
+//                     BOOST_VERIFY(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2007 Peter Dimov
+//  Copyright (c) Beman Dawes 2011
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 //  See http://www.boost.org/libs/utility/assert.html for documentation.
 //
 
+//
+// Stop inspect complaining about use of 'assert':
+//
+// boostinspect:naassert_macro
+//
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_ASSERT                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_ASSERT
 
 #if defined(BOOST_DISABLE_ASSERTS)
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 
+#include <boost/config.hpp>
 #include <boost/current_function.hpp>
 
 namespace boost
 {
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
-
+  void assertion_failed(char const * expr,
+                        char const * function, char const * file, long line); // user defined
 } // namespace boost
 
-#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr)) \
+  ? ((void)0) \
+  : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
 #else
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
 
+//--------------------------------------------------------------------------------------//
+//                                   BOOST_ASSERT_MSG                                   //
+//--------------------------------------------------------------------------------------//
+
+# undef BOOST_ASSERT_MSG
+
+#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG)
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((void)0)
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+
+  #include <boost/config.hpp>
+  #include <boost/current_function.hpp>
+
+  namespace boost
+  {
+    void assertion_failed_msg(char const * expr, char const * msg,
+                              char const * function, char const * file, long line); // user defined
+  } // namespace boost
+
+  #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
+    ? ((void)0) \
+    : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+  #ifndef BOOST_ASSERT_HPP
+    #define BOOST_ASSERT_HPP
+    #include <cstdlib>
+    #include <iostream>
+    #include <boost/config.hpp>
+    #include <boost/current_function.hpp>
+
+    //  IDE's like Visual Studio perform better if output goes to std::cout or
+    //  some other stream, so allow user to configure output stream:
+    #ifndef BOOST_ASSERT_MSG_OSTREAM
+    # define BOOST_ASSERT_MSG_OSTREAM std::cerr
+    #endif
+
+    namespace boost
+    {
+      namespace assertion
+      {
+        namespace detail
+        {
+          // Note: The template is needed to make the function non-inline and avoid linking errors
+          template< typename CharT >
+          BOOST_NOINLINE void assertion_failed_msg(CharT const * expr, char const * msg, char const * function,
+            char const * file, long line)
+          {
+            BOOST_ASSERT_MSG_OSTREAM
+              << "***** Internal Program Error - assertion (" << expr << ") failed in "
+              << function << ":\n"
+              << file << '(' << line << "): " << msg << std::endl;
+#ifdef UNDER_CE
+            // The Windows CE CRT library does not have abort() so use exit(-1) instead.
+            std::exit(-1);
+#else
+            std::abort();
+#endif
+          }
+        } // detail
+      } // assertion
+    } // detail
+  #endif
+
+  #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
+    ? ((void)0) \
+    : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
+          BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#endif
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_VERIFY                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_VERIFY
 
 #if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
diff --git a/boost/blank.hpp b/boost/blank.hpp
new file mode 100644 (file)
index 0000000..d0fe5ab
--- /dev/null
@@ -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 <iosfwd> // 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
diff --git a/boost/blank_fwd.hpp b/boost/blank_fwd.hpp
new file mode 100644 (file)
index 0000000..8bfe97c
--- /dev/null
@@ -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
diff --git a/boost/call_traits.hpp b/boost/call_traits.hpp
deleted file mode 100644 (file)
index 5253a6d..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
-
-//  See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_CALL_TRAITS_HPP
-#define BOOST_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_call_traits.hpp>
-#else
-#include <boost/detail/call_traits.hpp>
-#endif
-
-#endif // BOOST_CALL_TRAITS_HPP
diff --git a/boost/concept/assert.hpp b/boost/concept/assert.hpp
new file mode 100644 (file)
index 0000000..80eca81
--- /dev/null
@@ -0,0 +1,46 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_ASSERT_DWA2006430_HPP
+# define BOOST_CONCEPT_ASSERT_DWA2006430_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+
+// The old protocol used a constraints() member function in concept
+// checking classes.  If the compiler supports SFINAE, we can detect
+// that function and seamlessly support the old concept checking
+// classes.  In this release, backward compatibility with the old
+// concept checking classes is enabled by default, where available.
+// The old protocol is deprecated, though, and backward compatibility
+// will no longer be the default in the next release.
+
+# if !defined(BOOST_NO_OLD_CONCEPT_SUPPORT)                                         \
+    && !defined(BOOST_NO_SFINAE)                                                    \
+                                                                                    \
+    && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4)) \
+    && !(BOOST_WORKAROUND(__GNUC__, == 2))
+
+// Note: gcc-2.96 through 3.3.x have some SFINAE, but no ability to
+// check for the presence of particularmember functions.
+
+#  define BOOST_OLD_CONCEPT_SUPPORT
+
+# endif
+
+# ifdef BOOST_MSVC
+#  include <boost/concept/detail/msvc.hpp>
+# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#  include <boost/concept/detail/borland.hpp>
+# else 
+#  include <boost/concept/detail/general.hpp>
+# endif
+
+  // Usage, in class or function context:
+  //
+  //     BOOST_CONCEPT_ASSERT((UnaryFunctionConcept<F,bool,int>));
+  //
+# define BOOST_CONCEPT_ASSERT(ModelInParens) \
+    BOOST_CONCEPT_ASSERT_FN(void(*)ModelInParens)
+
+#endif // BOOST_CONCEPT_ASSERT_DWA2006430_HPP
diff --git a/boost/concept/detail/backward_compatibility.hpp b/boost/concept/detail/backward_compatibility.hpp
new file mode 100644 (file)
index 0000000..66d573e
--- /dev/null
@@ -0,0 +1,16 @@
+// Copyright David Abrahams 2009. Distributed under the 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_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
+# define BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
+
+namespace boost
+{
+  namespace concepts {}
+
+# if defined(BOOST_HAS_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD)
+  namespace concept = concepts;
+# endif 
+} // namespace boost::concept
+
+#endif // BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
diff --git a/boost/concept/detail/borland.hpp b/boost/concept/detail/borland.hpp
new file mode 100644 (file)
index 0000000..300d5d4
--- /dev/null
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
+# define BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
+
+# include <boost/preprocessor/cat.hpp>
+# include <boost/concept/detail/backward_compatibility.hpp>
+
+namespace boost { namespace concepts {
+
+template <class ModelFnPtr>
+struct require;
+
+template <class Model>
+struct require<void(*)(Model)>
+{
+    enum { instantiate = sizeof((((Model*)0)->~Model()), 3) };
+};
+
+#  define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )         \
+  enum                                                  \
+  {                                                     \
+      BOOST_PP_CAT(boost_concept_check,__LINE__) =      \
+      boost::concepts::require<ModelFnPtr>::instantiate  \
+  }
+
+}} // namespace boost::concept
+
+#endif // BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
diff --git a/boost/concept/detail/concept_def.hpp b/boost/concept/detail/concept_def.hpp
new file mode 100644 (file)
index 0000000..79f628e
--- /dev/null
@@ -0,0 +1,51 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
+# define BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
+# include <boost/preprocessor/seq/for_each_i.hpp>
+# include <boost/preprocessor/seq/enum.hpp>
+# include <boost/preprocessor/comma_if.hpp>
+# include <boost/preprocessor/cat.hpp>
+#endif // BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
+
+// BOOST_concept(SomeName, (p1)(p2)...(pN))
+//
+// Expands to "template <class p1, class p2, ...class pN> struct SomeName"
+//
+// Also defines an equivalent SomeNameConcept for backward compatibility.
+// Maybe in the next release we can kill off the "Concept" suffix for good.
+#if BOOST_WORKAROUND(__GNUC__, <= 3)
+# define BOOST_concept(name, params)                                            \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct name; /* forward declaration */                                      \
+                                                                                \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct BOOST_PP_CAT(name,Concept)                                           \
+      : name< BOOST_PP_SEQ_ENUM(params) >                                       \
+    {                                                                           \
+        /* at least 2.96 and 3.4.3 both need this */                            \
+        BOOST_PP_CAT(name,Concept)();                                           \
+    };                                                                          \
+                                                                                \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct name                                                                
+#else
+# define BOOST_concept(name, params)                                            \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct name; /* forward declaration */                                      \
+                                                                                \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct BOOST_PP_CAT(name,Concept)                                           \
+      : name< BOOST_PP_SEQ_ENUM(params) >                                       \
+    {                                                                           \
+    };                                                                          \
+                                                                                \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct name                                                                
+#endif
+    
+// Helper for BOOST_concept, above.
+# define BOOST_CONCEPT_typename(r, ignored, index, t) \
+    BOOST_PP_COMMA_IF(index) typename t
+
diff --git a/boost/concept/detail/concept_undef.hpp b/boost/concept/detail/concept_undef.hpp
new file mode 100644 (file)
index 0000000..713db89
--- /dev/null
@@ -0,0 +1,5 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# undef BOOST_concept_typename
+# undef BOOST_concept
diff --git a/boost/concept/detail/general.hpp b/boost/concept/detail/general.hpp
new file mode 100644 (file)
index 0000000..e3014c1
--- /dev/null
@@ -0,0 +1,75 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
+# define BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
+
+# include <boost/preprocessor/cat.hpp>
+# include <boost/concept/detail/backward_compatibility.hpp>
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+#  include <boost/concept/detail/has_constraints.hpp>
+#  include <boost/mpl/if.hpp>
+# endif
+
+// This implementation works on Comeau and GCC, all the way back to
+// 2.95
+namespace boost { namespace concepts {
+
+template <class ModelFn>
+struct requirement_;
+
+namespace detail
+{
+  template <void(*)()> struct instantiate {};
+}
+
+template <class Model>
+struct requirement
+{
+    static void failed() { ((Model*)0)->~Model(); }
+};
+
+struct failed {};
+
+template <class Model>
+struct requirement<failed ************ Model::************>
+{
+    static void failed() { ((Model*)0)->~Model(); }
+};
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+
+template <class Model>
+struct constraint
+{
+    static void failed() { ((Model*)0)->constraints(); }
+};
+  
+template <class Model>
+struct requirement_<void(*)(Model)>
+  : mpl::if_<
+        concepts::not_satisfied<Model>
+      , constraint<Model>
+      , requirement<failed ************ Model::************>
+    >::type
+{};
+  
+# else
+
+// For GCC-2.x, these can't have exactly the same name
+template <class Model>
+struct requirement_<void(*)(Model)>
+    : requirement<failed ************ Model::************>
+{};
+  
+# endif
+
+#  define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )             \
+    typedef ::boost::concepts::detail::instantiate<          \
+    &::boost::concepts::requirement_<ModelFnPtr>::failed>    \
+      BOOST_PP_CAT(boost_concept_check,__LINE__)
+
+}}
+
+#endif // BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
diff --git a/boost/concept/detail/has_constraints.hpp b/boost/concept/detail/has_constraints.hpp
new file mode 100644 (file)
index 0000000..a309db3
--- /dev/null
@@ -0,0 +1,50 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
+# define BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
+
+# include <boost/mpl/bool.hpp>
+# include <boost/detail/workaround.hpp>
+# include <boost/concept/detail/backward_compatibility.hpp>
+
+namespace boost { namespace concepts {
+
+namespace detail
+{ 
+
+// Here we implement the metafunction that detects whether a
+// constraints metafunction exists
+  typedef char yes;
+  typedef char (&no)[2];
+
+  template <class Model, void (Model::*)()>
+  struct wrap_constraints {};
+    
+#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580) || defined(__CUDACC__)
+  // Work around the following bogus error in Sun Studio 11, by
+  // turning off the has_constraints function entirely:
+  //    Error: complex expression not allowed in dependent template
+  //    argument expression
+  inline no has_constraints_(...);
+#else
+  template <class Model>
+  inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
+  inline no has_constraints_(...);
+#endif
+}
+
+// This would be called "detail::has_constraints," but it has a strong
+// tendency to show up in error messages.
+template <class Model>
+struct not_satisfied
+{
+    BOOST_STATIC_CONSTANT(
+        bool
+      , value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes) );
+    typedef mpl::bool_<value> type;
+};
+
+}} // namespace boost::concepts::detail
+
+#endif // BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
diff --git a/boost/concept/detail/msvc.hpp b/boost/concept/detail/msvc.hpp
new file mode 100644 (file)
index 0000000..9fbd250
--- /dev/null
@@ -0,0 +1,114 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
+# define BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
+
+# include <boost/preprocessor/cat.hpp>
+# include <boost/concept/detail/backward_compatibility.hpp>
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+#  include <boost/concept/detail/has_constraints.hpp>
+#  include <boost/mpl/if.hpp>
+# endif
+
+
+namespace boost { namespace concepts {
+
+
+template <class Model>
+struct check
+{
+    virtual void failed(Model* x)
+    {
+        x->~Model();
+    }
+};
+
+# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
+struct failed {};
+template <class Model>
+struct check<failed ************ Model::************>
+{
+    virtual void failed(Model* x)
+    {
+        x->~Model();
+    }
+};
+# endif
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+  
+namespace detail
+{
+  // No need for a virtual function here, since evaluating
+  // not_satisfied below will have already instantiated the
+  // constraints() member.
+  struct constraint {};
+}
+
+template <class Model>
+struct require
+  : mpl::if_c<
+        not_satisfied<Model>::value
+      , detail::constraint
+# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
+      , check<Model>
+# else
+      , check<failed ************ Model::************>
+# endif 
+        >::type
+{};
+      
+# else
+  
+template <class Model>
+struct require
+# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
+    : check<Model>
+# else
+    : check<failed ************ Model::************>
+# endif 
+{};
+  
+# endif
+    
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+//
+// The iterator library sees some really strange errors unless we
+// do things this way.
+//
+template <class Model>
+struct require<void(*)(Model)>
+{
+    virtual void failed(Model*)
+    {
+        require<Model>();
+    }
+};
+
+# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )      \
+enum                                                \
+{                                                   \
+    BOOST_PP_CAT(boost_concept_check,__LINE__) =    \
+    sizeof(::boost::concepts::require<ModelFnPtr>)    \
+}
+  
+# else // Not vc-7.1
+  
+template <class Model>
+require<Model>
+require_(void(*)(Model));
+  
+# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )          \
+enum                                                    \
+{                                                       \
+    BOOST_PP_CAT(boost_concept_check,__LINE__) =        \
+      sizeof(::boost::concepts::require_((ModelFnPtr)0)) \
+}
+  
+# endif
+}}
+
+#endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
diff --git a/boost/concept/usage.hpp b/boost/concept/usage.hpp
new file mode 100644 (file)
index 0000000..21547c3
--- /dev/null
@@ -0,0 +1,44 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_USAGE_DWA2006919_HPP
+# define BOOST_CONCEPT_USAGE_DWA2006919_HPP
+
+# include <boost/concept/assert.hpp>
+# include <boost/detail/workaround.hpp>
+# include <boost/concept/detail/backward_compatibility.hpp>
+
+namespace boost { namespace concepts { 
+
+# if BOOST_WORKAROUND(__GNUC__, == 2)
+
+#  define BOOST_CONCEPT_USAGE(model) ~model()
+
+# else 
+
+template <class Model>
+struct usage_requirements
+{
+    ~usage_requirements() { ((Model*)0)->~Model(); }
+};
+
+#  if BOOST_WORKAROUND(__GNUC__, <= 3)
+
+#   define BOOST_CONCEPT_USAGE(model)                                    \
+      model(); /* at least 2.96 and 3.4.3 both need this :( */           \
+      BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements<model>)); \
+      ~model()
+
+#  else
+
+#   define BOOST_CONCEPT_USAGE(model)                                    \
+      BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements<model>)); \
+      ~model()
+
+#  endif
+
+# endif 
+
+}} // namespace boost::concepts
+
+#endif // BOOST_CONCEPT_USAGE_DWA2006919_HPP
diff --git a/boost/concept_check.hpp b/boost/concept_check.hpp
new file mode 100644 (file)
index 0000000..bf5a2af
--- /dev/null
@@ -0,0 +1,1083 @@
+//
+// (C) Copyright Jeremy Siek 2000.
+// Copyright 2002 The Trustees of Indiana University.
+//
+// Distributed under the 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:
+//   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)
+//   02 April 2001: Removed limits header altogether. (Jeremy Siek)
+//   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)
+//
+
+// See http://www.boost.org/libs/concept_check for documentation.
+
+#ifndef BOOST_CONCEPT_CHECKS_HPP
+# define BOOST_CONCEPT_CHECKS_HPP
+
+# include <boost/concept/assert.hpp>
+
+# include <boost/iterator.hpp>
+# include <boost/type_traits/conversion_traits.hpp>
+# include <utility>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_void.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/detail/workaround.hpp>
+# include <boost/detail/iterator.hpp>
+
+# include <boost/concept/usage.hpp>
+# include <boost/concept/detail/concept_def.hpp>
+
+namespace boost
+{
+
+  //
+  // Backward compatibility
+  //
+
+  template <class Model>
+  inline void function_requires(Model* = 0)
+  {
+      BOOST_CONCEPT_ASSERT((Model));
+  }
+  template <class T> inline void ignore_unused_variable_warning(T const&) {}
+
+#  define BOOST_CLASS_REQUIRE(type_var, ns, concept)    \
+    BOOST_CONCEPT_ASSERT((ns::concept<type_var>))
+
+#  define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept)   \
+    BOOST_CONCEPT_ASSERT((ns::concept<type_var1,type_var2>))
+
+#  define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept)  \
+    BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3>))
+
+#  define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
+    BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>))
+
+
+  //
+  // Begin concept definitions
+  //
+  BOOST_concept(Integer, (T))
+  {
+      BOOST_CONCEPT_USAGE(Integer)
+        {
+            x.error_type_must_be_an_integer_type();
+        }
+   private:
+      T x;
+  };
+
+  template <> struct Integer<char> {};
+  template <> struct Integer<signed char> {};
+  template <> struct Integer<unsigned char> {};
+  template <> struct Integer<short> {};
+  template <> struct Integer<unsigned short> {};
+  template <> struct Integer<int> {};
+  template <> struct Integer<unsigned int> {};
+  template <> struct Integer<long> {};
+  template <> struct Integer<unsigned long> {};
+# if defined(BOOST_HAS_LONG_LONG)
+  template <> struct Integer< ::boost::long_long_type> {};
+  template <> struct Integer< ::boost::ulong_long_type> {};
+# elif defined(BOOST_HAS_MS_INT64)
+  template <> struct Integer<__int64> {};
+  template <> struct Integer<unsigned __int64> {};
+# endif
+
+  BOOST_concept(SignedInteger,(T)) {
+    BOOST_CONCEPT_USAGE(SignedInteger) {
+      x.error_type_must_be_a_signed_integer_type();
+    }
+   private:
+    T x;
+  };
+  template <> struct SignedInteger<signed char> { };
+  template <> struct SignedInteger<short> {};
+  template <> struct SignedInteger<int> {};
+  template <> struct SignedInteger<long> {};
+# if defined(BOOST_HAS_LONG_LONG)
+  template <> struct SignedInteger< ::boost::long_long_type> {};
+# elif defined(BOOST_HAS_MS_INT64)
+  template <> struct SignedInteger<__int64> {};
+# endif
+
+  BOOST_concept(UnsignedInteger,(T)) {
+    BOOST_CONCEPT_USAGE(UnsignedInteger) {
+      x.error_type_must_be_an_unsigned_integer_type();
+    }
+   private:
+    T x;
+  };
+
+  template <> struct UnsignedInteger<unsigned char> {};
+  template <> struct UnsignedInteger<unsigned short> {};
+  template <> struct UnsignedInteger<unsigned int> {};
+  template <> struct UnsignedInteger<unsigned long> {};
+# if defined(BOOST_HAS_LONG_LONG)
+  template <> struct UnsignedInteger< ::boost::ulong_long_type> {};
+# elif defined(BOOST_HAS_MS_INT64)
+  template <> struct UnsignedInteger<unsigned __int64> {};
+# endif
+
+  //===========================================================================
+  // Basic Concepts
+
+  BOOST_concept(DefaultConstructible,(TT))
+  {
+    BOOST_CONCEPT_USAGE(DefaultConstructible) {
+      TT a;               // require default constructor
+      ignore_unused_variable_warning(a);
+    }
+  };
+
+  BOOST_concept(Assignable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(Assignable) {
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = b;             // require assignment operator
+#endif
+      const_constraints(b);
+    }
+   private:
+    void const_constraints(const TT& x) {
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = x;              // const required for argument to assignment
+#else
+      ignore_unused_variable_warning(x);
+#endif
+    }
+   private:
+    TT a;
+    TT b;
+  };
+
+
+  BOOST_concept(CopyConstructible,(TT))
+  {
+    BOOST_CONCEPT_USAGE(CopyConstructible) {
+      TT a(b);            // require copy constructor
+      TT* ptr = &a;       // require address of operator
+      const_constraints(a);
+      ignore_unused_variable_warning(ptr);
+    }
+   private:
+    void const_constraints(const TT& a) {
+      TT c(a);            // require const copy constructor
+      const TT* ptr = &a; // require const address of operator
+      ignore_unused_variable_warning(c);
+      ignore_unused_variable_warning(ptr);
+    }
+    TT b;
+  };
+
+#if (defined _MSC_VER)
+# pragma warning( push )
+# pragma warning( disable : 4510 ) // default constructor could not be generated
+# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
+#endif
+  // The SGI STL version of Assignable requires copy constructor and operator=
+  BOOST_concept(SGIAssignable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(SGIAssignable) {
+      TT c(a);
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = b;              // require assignment operator
+#endif
+      const_constraints(b);
+      ignore_unused_variable_warning(c);
+    }
+   private:
+    void const_constraints(const TT& x) {
+      TT c(x);
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = x;              // const required for argument to assignment
+#endif
+      ignore_unused_variable_warning(c);
+    }
+    TT a;
+    TT b;
+  };
+#if (defined _MSC_VER)
+# pragma warning( pop )
+#endif
+
+  BOOST_concept(Convertible,(X)(Y))
+  {
+    BOOST_CONCEPT_USAGE(Convertible) {
+      Y y = x;
+      ignore_unused_variable_warning(y);
+    }
+   private:
+    X x;
+  };
+
+  // The C++ standard requirements for many concepts talk about return
+  // types that must be "convertible to bool".  The problem with this
+  // requirement is that it leaves the door open for evil proxies that
+  // define things like operator|| with strange return types.  Two
+  // possible solutions are:
+  // 1) require the return type to be exactly bool
+  // 2) stay with convertible to bool, and also
+  //    specify stuff about all the logical operators.
+  // For now we just test for convertible to bool.
+  template <class TT>
+  void require_boolean_expr(const TT& t) {
+    bool x = t;
+    ignore_unused_variable_warning(x);
+  }
+
+  BOOST_concept(EqualityComparable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(EqualityComparable) {
+      require_boolean_expr(a == b);
+      require_boolean_expr(a != b);
+    }
+   private:
+    TT a, b;
+  };
+
+  BOOST_concept(LessThanComparable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(LessThanComparable) {
+      require_boolean_expr(a < b);
+    }
+   private:
+    TT a, b;
+  };
+
+  // This is equivalent to SGI STL's LessThanComparable.
+  BOOST_concept(Comparable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(Comparable) {
+      require_boolean_expr(a < b);
+      require_boolean_expr(a > b);
+      require_boolean_expr(a <= b);
+      require_boolean_expr(a >= b);
+    }
+   private:
+    TT a, b;
+  };
+
+#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME)    \
+  BOOST_concept(NAME, (First)(Second))                          \
+  {                                                             \
+      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                         \
+     private:                                                   \
+        bool constraints_() { return a OP b; }                  \
+        First a;                                                \
+        Second b;                                               \
+  }
+
+#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME)    \
+  BOOST_concept(NAME, (Ret)(First)(Second))                 \
+  {                                                         \
+      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                     \
+  private:                                                  \
+      Ret constraints_() { return a OP b; }                 \
+      First a;                                              \
+      Second b;                                             \
+  }
+
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOp);
+
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOp);
+
+  //===========================================================================
+  // Function Object Concepts
+
+  BOOST_concept(Generator,(Func)(Return))
+  {
+      BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
+
+   private:
+      void test(boost::mpl::false_)
+      {
+          // Do we really want a reference here?
+          const Return& r = f();
+          ignore_unused_variable_warning(r);
+      }
+
+      void test(boost::mpl::true_)
+      {
+          f();
+      }
+
+      Func f;
+  };
+
+  BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
+  {
+      BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
+
+   private:
+      void test(boost::mpl::false_)
+      {
+          f(arg);               // "priming the pump" this way keeps msvc6 happy (ICE)
+          Return r = f(arg);
+          ignore_unused_variable_warning(r);
+      }
+
+      void test(boost::mpl::true_)
+      {
+          f(arg);
+      }
+
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy construktor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::UnaryFunction<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      UnaryFunction();
+#endif
+
+      Func f;
+      Arg arg;
+  };
+
+  BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second))
+  {
+      BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); }
+   private:
+      void test(boost::mpl::false_)
+      {
+          f(first,second);
+          Return r = f(first, second); // require operator()
+          (void)r;
+      }
+
+      void test(boost::mpl::true_)
+      {
+          f(first,second);
+      }
+
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::BinaryFunction<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      BinaryFunction();
+#endif
+
+      Func f;
+      First first;
+      Second second;
+  };
+
+  BOOST_concept(UnaryPredicate,(Func)(Arg))
+  {
+    BOOST_CONCEPT_USAGE(UnaryPredicate) {
+      require_boolean_expr(f(arg)); // require operator() returning bool
+    }
+   private:
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::UnaryPredicate<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      UnaryPredicate();
+#endif
+
+    Func f;
+    Arg arg;
+  };
+
+  BOOST_concept(BinaryPredicate,(Func)(First)(Second))
+  {
+    BOOST_CONCEPT_USAGE(BinaryPredicate) {
+      require_boolean_expr(f(a, b)); // require operator() returning bool
+    }
+   private:
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::BinaryPredicate<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      BinaryPredicate();
+#endif
+    Func f;
+    First a;
+    Second b;
+  };
+
+  // use this when functor is used inside a container class like std::set
+  BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
+    : BinaryPredicate<Func, First, Second>
+  {
+    BOOST_CONCEPT_USAGE(Const_BinaryPredicate) {
+      const_constraints(f);
+    }
+   private:
+    void const_constraints(const Func& fun) {
+      // operator() must be a const member function
+      require_boolean_expr(fun(a, b));
+    }
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::Const_BinaryPredicate<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      Const_BinaryPredicate();
+#endif
+
+    Func f;
+    First a;
+    Second b;
+  };
+
+  BOOST_concept(AdaptableGenerator,(Func)(Return))
+    : Generator<Func, typename Func::result_type>
+  {
+      typedef typename Func::result_type result_type;
+
+      BOOST_CONCEPT_USAGE(AdaptableGenerator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
+      }
+  };
+
+  BOOST_concept(AdaptableUnaryFunction,(Func)(Return)(Arg))
+    : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>
+  {
+      typedef typename Func::argument_type argument_type;
+      typedef typename Func::result_type result_type;
+
+      ~AdaptableUnaryFunction()
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
+          BOOST_CONCEPT_ASSERT((Convertible<Arg, argument_type>));
+      }
+  };
+
+  BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second))
+    : BinaryFunction<
+          Func
+        , typename Func::result_type
+        , typename Func::first_argument_type
+        , typename Func::second_argument_type
+      >
+  {
+      typedef typename Func::first_argument_type first_argument_type;
+      typedef typename Func::second_argument_type second_argument_type;
+      typedef typename Func::result_type result_type;
+
+      ~AdaptableBinaryFunction()
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
+          BOOST_CONCEPT_ASSERT((Convertible<First, first_argument_type>));
+          BOOST_CONCEPT_ASSERT((Convertible<Second, second_argument_type>));
+      }
+  };
+
+  BOOST_concept(AdaptablePredicate,(Func)(Arg))
+    : UnaryPredicate<Func, Arg>
+    , AdaptableUnaryFunction<Func, bool, Arg>
+  {
+  };
+
+  BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second))
+    : BinaryPredicate<Func, First, Second>
+    , AdaptableBinaryFunction<Func, bool, First, Second>
+  {
+  };
+
+  //===========================================================================
+  // Iterator Concepts
+
+  BOOST_concept(InputIterator,(TT))
+    : Assignable<TT>
+    , EqualityComparable<TT>
+  {
+      typedef typename boost::detail::iterator_traits<TT>::value_type value_type;
+      typedef typename boost::detail::iterator_traits<TT>::difference_type difference_type;
+      typedef typename boost::detail::iterator_traits<TT>::reference reference;
+      typedef typename boost::detail::iterator_traits<TT>::pointer pointer;
+      typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;
+
+      BOOST_CONCEPT_USAGE(InputIterator)
+      {
+        BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));
+        BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));
+
+        TT j(i);
+        (void)*i;           // require dereference operator
+        ++j;                // require preincrement operator
+        i++;                // require postincrement operator
+      }
+   private:
+    TT i;
+  };
+
+  BOOST_concept(OutputIterator,(TT)(ValueT))
+    : Assignable<TT>
+  {
+    BOOST_CONCEPT_USAGE(OutputIterator) {
+
+      ++i;                // require preincrement operator
+      i++;                // require postincrement operator
+      *i++ = t;           // require postincrement and assignment
+    }
+   private:
+    TT i, j;
+    ValueT t;
+  };
+
+  BOOST_concept(ForwardIterator,(TT))
+    : InputIterator<TT>
+  {
+      BOOST_CONCEPT_USAGE(ForwardIterator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<
+              BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
+            , std::forward_iterator_tag
+          >));
+
+          typename InputIterator<TT>::reference r = *i;
+          ignore_unused_variable_warning(r);
+      }
+
+   private:
+      TT i;
+  };
+
+  BOOST_concept(Mutable_ForwardIterator,(TT))
+    : ForwardIterator<TT>
+  {
+      BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
+        *i++ = *i;         // require postincrement and assignment
+      }
+   private:
+      TT i;
+  };
+
+  BOOST_concept(BidirectionalIterator,(TT))
+    : ForwardIterator<TT>
+  {
+      BOOST_CONCEPT_USAGE(BidirectionalIterator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<
+              BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
+            , std::bidirectional_iterator_tag
+          >));
+
+          --i;                // require predecrement operator
+          i--;                // require postdecrement operator
+      }
+   private:
+      TT i;
+  };
+
+  BOOST_concept(Mutable_BidirectionalIterator,(TT))
+    : BidirectionalIterator<TT>
+    , Mutable_ForwardIterator<TT>
+  {
+      BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
+      {
+          *i-- = *i;                  // require postdecrement and assignment
+      }
+   private:
+      TT i;
+  };
+
+  BOOST_concept(RandomAccessIterator,(TT))
+    : BidirectionalIterator<TT>
+    , Comparable<TT>
+  {
+      BOOST_CONCEPT_USAGE(RandomAccessIterator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<
+              BOOST_DEDUCED_TYPENAME BidirectionalIterator<TT>::iterator_category
+            , std::random_access_iterator_tag
+          >));
+
+          i += n;             // require assignment addition operator
+          i = i + n; i = n + i; // require addition with difference type
+          i -= n;             // require assignment subtraction operator
+          i = i - n;                  // require subtraction with difference type
+          n = i - j;                  // require difference operator
+          (void)i[n];                 // require element access operator
+      }
+
+   private:
+    TT a, b;
+    TT i, j;
+      typename boost::detail::iterator_traits<TT>::difference_type n;
+  };
+
+  BOOST_concept(Mutable_RandomAccessIterator,(TT))
+    : RandomAccessIterator<TT>
+    , Mutable_BidirectionalIterator<TT>
+  {
+      BOOST_CONCEPT_USAGE(Mutable_RandomAccessIterator)
+      {
+          i[n] = *i;                  // require element access and assignment
+      }
+   private:
+    TT i;
+    typename boost::detail::iterator_traits<TT>::difference_type n;
+  };
+
+  //===========================================================================
+  // Container s
+
+  BOOST_concept(Container,(C))
+    : Assignable<C>
+  {
+    typedef typename C::value_type value_type;
+    typedef typename C::difference_type difference_type;
+    typedef typename C::size_type size_type;
+    typedef typename C::const_reference const_reference;
+    typedef typename C::const_pointer const_pointer;
+    typedef typename C::const_iterator const_iterator;
+
+      BOOST_CONCEPT_USAGE(Container)
+      {
+          BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>));
+          const_constraints(c);
+      }
+
+   private:
+      void const_constraints(const C& cc) {
+          i = cc.begin();
+          i = cc.end();
+          n = cc.size();
+          n = cc.max_size();
+          b = cc.empty();
+      }
+      C c;
+      bool b;
+      const_iterator i;
+      size_type n;
+  };
+
+  BOOST_concept(Mutable_Container,(C))
+    : Container<C>
+  {
+      typedef typename C::reference reference;
+      typedef typename C::iterator iterator;
+      typedef typename C::pointer pointer;
+
+      BOOST_CONCEPT_USAGE(Mutable_Container)
+      {
+          BOOST_CONCEPT_ASSERT((
+               Assignable<typename Mutable_Container::value_type>));
+
+          BOOST_CONCEPT_ASSERT((InputIterator<iterator>));
+
+          i = c.begin();
+          i = c.end();
+          c.swap(c2);
+      }
+
+   private:
+      iterator i;
+      C c, c2;
+  };
+
+  BOOST_concept(ForwardContainer,(C))
+    : Container<C>
+  {
+      BOOST_CONCEPT_USAGE(ForwardContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+               ForwardIterator<
+                    typename ForwardContainer::const_iterator
+               >));
+      }
+  };
+
+  BOOST_concept(Mutable_ForwardContainer,(C))
+    : ForwardContainer<C>
+    , Mutable_Container<C>
+  {
+      BOOST_CONCEPT_USAGE(Mutable_ForwardContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+               Mutable_ForwardIterator<
+                   typename Mutable_ForwardContainer::iterator
+               >));
+      }
+  };
+
+  BOOST_concept(ReversibleContainer,(C))
+    : ForwardContainer<C>
+  {
+      typedef typename
+        C::const_reverse_iterator
+      const_reverse_iterator;
+
+      BOOST_CONCEPT_USAGE(ReversibleContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+              BidirectionalIterator<
+                  typename ReversibleContainer::const_iterator>));
+
+          BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>));
+
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc)
+      {
+          const_reverse_iterator i = cc.rbegin();
+          i = cc.rend();
+      }
+      C c;
+  };
+
+  BOOST_concept(Mutable_ReversibleContainer,(C))
+    : Mutable_ForwardContainer<C>
+    , ReversibleContainer<C>
+  {
+      typedef typename C::reverse_iterator reverse_iterator;
+
+      BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
+      {
+          typedef typename Mutable_ForwardContainer<C>::iterator iterator;
+          BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>));
+          BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>));
+
+          reverse_iterator i = c.rbegin();
+          i = c.rend();
+      }
+   private:
+      C c;
+  };
+
+  BOOST_concept(RandomAccessContainer,(C))
+    : ReversibleContainer<C>
+  {
+      typedef typename C::size_type size_type;
+      typedef typename C::const_reference const_reference;
+
+      BOOST_CONCEPT_USAGE(RandomAccessContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+              RandomAccessIterator<
+                  typename RandomAccessContainer::const_iterator
+              >));
+
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc)
+      {
+          const_reference r = cc[n];
+          ignore_unused_variable_warning(r);
+      }
+
+      C c;
+      size_type n;
+  };
+
+  BOOST_concept(Mutable_RandomAccessContainer,(C))
+    : Mutable_ReversibleContainer<C>
+    , RandomAccessContainer<C>
+  {
+   private:
+      typedef Mutable_RandomAccessContainer self;
+   public:
+      BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer)
+      {
+          BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>));
+          BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>));
+
+          typename self::reference r = c[i];
+          ignore_unused_variable_warning(r);
+      }
+
+   private:
+      typename Mutable_ReversibleContainer<C>::size_type i;
+      C c;
+  };
+
+  // A Sequence is inherently mutable
+  BOOST_concept(Sequence,(S))
+    : Mutable_ForwardContainer<S>
+      // Matt Austern's book puts DefaultConstructible here, the C++
+      // standard places it in Container --JGS
+      // ... so why aren't we following the standard?  --DWA
+    , DefaultConstructible<S>
+  {
+      BOOST_CONCEPT_USAGE(Sequence)
+      {
+          S
+              c(n),
+              c2(n, t),
+              c3(first, last);
+
+          c.insert(p, t);
+          c.insert(p, n, t);
+          c.insert(p, first, last);
+
+          c.erase(p);
+          c.erase(p, q);
+
+          typename Sequence::reference r = c.front();
+
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(c2);
+          ignore_unused_variable_warning(c3);
+          ignore_unused_variable_warning(r);
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const S& c) {
+          typename Sequence::const_reference r = c.front();
+          ignore_unused_variable_warning(r);
+      }
+
+      typename S::value_type t;
+      typename S::size_type n;
+      typename S::value_type* first, *last;
+      typename S::iterator p, q;
+  };
+
+  BOOST_concept(FrontInsertionSequence,(S))
+    : Sequence<S>
+  {
+      BOOST_CONCEPT_USAGE(FrontInsertionSequence)
+      {
+          c.push_front(t);
+          c.pop_front();
+      }
+   private:
+      S c;
+      typename S::value_type t;
+  };
+
+  BOOST_concept(BackInsertionSequence,(S))
+    : Sequence<S>
+  {
+      BOOST_CONCEPT_USAGE(BackInsertionSequence)
+      {
+          c.push_back(t);
+          c.pop_back();
+          typename BackInsertionSequence::reference r = c.back();
+          ignore_unused_variable_warning(r);
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const S& cc) {
+          typename BackInsertionSequence::const_reference
+              r = cc.back();
+          ignore_unused_variable_warning(r);
+      };
+      S c;
+      typename S::value_type t;
+  };
+
+  BOOST_concept(AssociativeContainer,(C))
+    : ForwardContainer<C>
+    , DefaultConstructible<C>
+  {
+      typedef typename C::key_type key_type;
+      typedef typename C::key_compare key_compare;
+      typedef typename C::value_compare value_compare;
+      typedef typename C::iterator iterator;
+
+      BOOST_CONCEPT_USAGE(AssociativeContainer)
+      {
+          i = c.find(k);
+          r = c.equal_range(k);
+          c.erase(k);
+          c.erase(i);
+          c.erase(r.first, r.second);
+          const_constraints(c);
+          BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>));
+
+          typedef typename AssociativeContainer::value_type value_type_;
+          BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>));
+      }
+
+      // Redundant with the base concept, but it helps below.
+      typedef typename C::const_iterator const_iterator;
+   private:
+      void const_constraints(const C& cc)
+      {
+          ci = cc.find(k);
+          n = cc.count(k);
+          cr = cc.equal_range(k);
+      }
+
+      C c;
+      iterator i;
+      std::pair<iterator,iterator> r;
+      const_iterator ci;
+      std::pair<const_iterator,const_iterator> cr;
+      typename C::key_type k;
+      typename C::size_type n;
+  };
+
+  BOOST_concept(UniqueAssociativeContainer,(C))
+    : AssociativeContainer<C>
+  {
+      BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
+      {
+          C c(first, last);
+
+          pos_flag = c.insert(t);
+          c.insert(first, last);
+
+          ignore_unused_variable_warning(c);
+      }
+   private:
+      std::pair<typename C::iterator, bool> pos_flag;
+      typename C::value_type t;
+      typename C::value_type* first, *last;
+  };
+
+  BOOST_concept(MultipleAssociativeContainer,(C))
+    : AssociativeContainer<C>
+  {
+      BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
+      {
+          C c(first, last);
+
+          pos = c.insert(t);
+          c.insert(first, last);
+
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(pos);
+      }
+   private:
+      typename C::iterator pos;
+      typename C::value_type t;
+      typename C::value_type* first, *last;
+  };
+
+  BOOST_concept(SimpleAssociativeContainer,(C))
+    : AssociativeContainer<C>
+  {
+      BOOST_CONCEPT_USAGE(SimpleAssociativeContainer)
+      {
+          typedef typename C::key_type key_type;
+          typedef typename C::value_type value_type;
+          BOOST_MPL_ASSERT((boost::is_same<key_type,value_type>));
+      }
+  };
+
+  BOOST_concept(PairAssociativeContainer,(C))
+    : AssociativeContainer<C>
+  {
+      BOOST_CONCEPT_USAGE(PairAssociativeContainer)
+      {
+          typedef typename C::key_type key_type;
+          typedef typename C::value_type value_type;
+          typedef typename C::mapped_type mapped_type;
+          typedef std::pair<const key_type, mapped_type> required_value_type;
+          BOOST_MPL_ASSERT((boost::is_same<value_type,required_value_type>));
+      }
+  };
+
+  BOOST_concept(SortedAssociativeContainer,(C))
+    : AssociativeContainer<C>
+    , ReversibleContainer<C>
+  {
+      BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
+      {
+          C
+              c(kc),
+              c2(first, last),
+              c3(first, last, kc);
+
+          p = c.upper_bound(k);
+          p = c.lower_bound(k);
+          r = c.equal_range(k);
+
+          c.insert(p, t);
+
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(c2);
+          ignore_unused_variable_warning(c3);
+          const_constraints(c);
+      }
+
+      void const_constraints(const C& c)
+      {
+          kc = c.key_comp();
+          vc = c.value_comp();
+
+          cp = c.upper_bound(k);
+          cp = c.lower_bound(k);
+          cr = c.equal_range(k);
+      }
+
+   private:
+      typename C::key_compare kc;
+      typename C::value_compare vc;
+      typename C::value_type t;
+      typename C::key_type k;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+
+      typedef SortedAssociativeContainer self;
+      iterator p;
+      const_iterator cp;
+      std::pair<typename self::iterator,typename self::iterator> r;
+      std::pair<typename self::const_iterator,typename self::const_iterator> cr;
+      typename C::value_type* first, *last;
+  };
+
+  // HashedAssociativeContainer
+
+  BOOST_concept(Collection,(C))
+  {
+      BOOST_CONCEPT_USAGE(Collection)
+      {
+        boost::function_requires<boost::InputIteratorConcept<iterator> >();
+        boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+        boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
+        const_constraints(c);
+        i = c.begin();
+        i = c.end();
+        c.swap(c);
+      }
+
+      void const_constraints(const C& cc) {
+        ci = cc.begin();
+        ci = cc.end();
+        n = cc.size();
+        b = cc.empty();
+      }
+
+    private:
+      typedef typename C::value_type value_type;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+      typedef typename C::reference reference;
+      typedef typename C::const_reference const_reference;
+      // typedef typename C::pointer pointer;
+      typedef typename C::difference_type difference_type;
+      typedef typename C::size_type size_type;
+
+      C c;
+      bool b;
+      iterator i;
+      const_iterator ci;
+      size_type n;
+  };
+} // namespace boost
+
+# include <boost/concept/detail/concept_undef.hpp>
+
+#endif // BOOST_CONCEPT_CHECKS_HPP
+
index 055a278..6ec3645 100644 (file)
@@ -1,6 +1,6 @@
 //  Boost config.hpp configuration header file  ------------------------------//
 
-//  (C) Copyright John Maddock 2002. 
+//  (C) Copyright John Maddock 2002.
 //  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)
@@ -36,7 +36,7 @@
 #endif
 
 // if we don't have a std library config set, try and find one:
-#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG)
+#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus)
 #  include <boost/config/select_stdlib_config.hpp>
 #endif
 // if we have a std library config, include it now:
 // get config suffix code:
 #include <boost/config/suffix.hpp>
 
-#endif  // BOOST_CONFIG_HPP
-
-
-
-
-
-
-
-
-
-
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
 
+#endif  // BOOST_CONFIG_HPP
index 0d17eb8..13cbad4 100644 (file)
@@ -60,14 +60,14 @@ BOOST_LIB_THREAD_OPT: "-mt" for multithread builds, otherwise nothing.
 
 BOOST_LIB_RT_OPT:     A suffix that indicates the runtime library used,
                       contains one or more of the following letters after
-                      a hiphen:
+                      a hyphen:
 
                       s      static runtime (dynamic if not present).
                       g      debug/diagnostic runtime (release if not present).
                       y      Python debug/diagnostic runtime (release if not present).
                       d      debug build (release if not present).
-                      g      debug/diagnostic runtime (release if not present).
-                      p      STLPort Build.
+                      p      STLport build.
+                      n      STLport build without its IOStreams.
 
 BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 
@@ -114,63 +114,74 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 // select toolset if not defined already:
 //
 #ifndef BOOST_LIB_TOOLSET
-// Note: no compilers before 1200 are supported
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#  if defined(BOOST_MSVC) && (BOOST_MSVC < 1200)
+    // Note: no compilers before 1200 are supported
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
 
-#  ifdef UNDER_CE
-     // vc6:
-#    define BOOST_LIB_TOOLSET "evc4"
-#  else
-     // vc6:
-#    define BOOST_LIB_TOOLSET "vc6"
-#  endif
+#    ifdef UNDER_CE
+       // eVC4:
+#      define BOOST_LIB_TOOLSET "evc4"
+#    else
+       // vc6:
+#      define BOOST_LIB_TOOLSET "vc6"
+#    endif
 
-#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1310)
 
-   // vc7:
-#  define BOOST_LIB_TOOLSET "vc7"
+     // vc7:
+#    define BOOST_LIB_TOOLSET "vc7"
 
-#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1310)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1400)
 
-   // vc71:
-#  define BOOST_LIB_TOOLSET "vc71"
+     // vc71:
+#    define BOOST_LIB_TOOLSET "vc71"
 
-#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1400)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1500)
 
-   // vc80:
-#  define BOOST_LIB_TOOLSET "vc80"
+     // vc80:
+#    define BOOST_LIB_TOOLSET "vc80"
 
-#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1500)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1600)
 
-   // vc90:
-#  define BOOST_LIB_TOOLSET "vc90"
+     // vc90:
+#    define BOOST_LIB_TOOLSET "vc90"
 
-#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1700)
 
-   // vc10:
-#  define BOOST_LIB_TOOLSET "vc100"
+     // vc10:
+#    define BOOST_LIB_TOOLSET "vc100"
 
-#elif defined(__BORLANDC__)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1800)
 
-   // CBuilder 6:
-#  define BOOST_LIB_TOOLSET "bcb"
+     // vc11:
+#    define BOOST_LIB_TOOLSET "vc110"
 
-#elif defined(__ICL)
+#  elif defined(BOOST_MSVC)
 
-   // Intel C++, no version number:
-#  define BOOST_LIB_TOOLSET "iw"
+     // vc12:
+#    define BOOST_LIB_TOOLSET "vc120"
 
-#elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF )
+#  elif defined(__BORLANDC__)
 
-   // Metrowerks CodeWarrior 8.x
-#  define BOOST_LIB_TOOLSET "cw8"
+     // CBuilder 6:
+#    define BOOST_LIB_TOOLSET "bcb"
 
-#elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF )
+#  elif defined(__ICL)
 
-   // Metrowerks CodeWarrior 9.x
-#  define BOOST_LIB_TOOLSET "cw9"
+     // Intel C++, no version number:
+#    define BOOST_LIB_TOOLSET "iw"
 
-#endif
+#  elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF )
+
+     // Metrowerks CodeWarrior 8.x
+#    define BOOST_LIB_TOOLSET "cw8"
+
+#  elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF )
+
+     // Metrowerks CodeWarrior 9.x
+#    define BOOST_LIB_TOOLSET "cw9"
+
+#  endif
 #endif // BOOST_LIB_TOOLSET
 
 //
@@ -196,11 +207,11 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #        elif defined(_DEBUG)\
                && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gydp"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #            define BOOST_LIB_RT_OPT "-gdp"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-p"
@@ -216,11 +227,11 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #        elif defined(_DEBUG)\
                && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gydpn"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #            define BOOST_LIB_RT_OPT "-gdpn"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-pn"
@@ -250,11 +261,11 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #        elif defined(_DEBUG)\
                && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #             define BOOST_LIB_RT_OPT "-sgydp"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #             define BOOST_LIB_RT_OPT "-sgdp"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-sp"
@@ -270,11 +281,11 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #        elif defined(_DEBUG)\
                && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #             define BOOST_LIB_RT_OPT "-sgydpn"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #             define BOOST_LIB_RT_OPT "-sgdpn"
-#            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-spn"
@@ -307,7 +318,7 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 // sanity check:
 //
 #if defined(__STL_DEBUG) || defined(_STLP_DEBUG)
-#error "Pre-built versions of the Boost libraries are not provided in STLPort-debug form"
+#error "Pre-built versions of the Boost libraries are not provided in STLport-debug form"
 #endif
 
 #  ifdef _RTLDLL
@@ -362,9 +373,9 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
       && defined(BOOST_LIB_VERSION)
 
 #ifdef BOOST_AUTO_LINK_TAGGED
-#  pragma commentcomment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
-#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
 #  endif
 #elif defined(BOOST_AUTO_LINK_NOMANGLE)
 #  pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
@@ -414,7 +425,5 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #if defined(BOOST_DYN_LINK)
 #  undef BOOST_DYN_LINK
 #endif
-#if defined(BOOST_AUTO_LINK_NOMANGLE)
-#  undef BOOST_AUTO_LINK_NOMANGLE
-#endif
+
 
index bd3a8c3..a8f5baa 100644 (file)
@@ -46,6 +46,8 @@
 // Borland C++Builder 5, command-line compiler 5.5:
 #       define BOOST_NO_OPERATORS_IN_NAMESPACE
 #     endif
+// Variadic macros do not exist for C++ Builder versions 5 and below
+#define BOOST_NO_CXX11_VARIADIC_MACROS
 #   endif
 
 // Version 5.51 and below:
 #  define BOOST_NO_CV_VOID_SPECIALIZATIONS
 #  define BOOST_NO_DEDUCED_TYPENAME
 // workaround for missing WCHAR_MAX/WCHAR_MIN:
+#ifdef __cplusplus
 #include <climits>
 #include <cwchar>
+#else
+#include <limits.h>
+#include <wchar.h>
+#endif // __cplusplus
 #ifndef WCHAR_MAX
 #  define WCHAR_MAX 0xffff
 #endif
@@ -67,7 +74,7 @@
 // Borland C++ Builder 6 and below:
 #if (__BORLANDC__ <= 0x564)
 
-#  ifdef NDEBUG
+#  if defined(NDEBUG) && defined(__cplusplus)
       // fix broken <cstring> so that Boost.test works:
 #     include <cstring>
 #     undef strcmp
 // C++0x Macros:
 //
 #if !defined( BOOST_CODEGEAR_0X_SUPPORT ) || (__BORLANDC__ < 0x610)
-#  define BOOST_NO_CHAR16_T
-#  define BOOST_NO_CHAR32_T
-#  define BOOST_NO_DECLTYPE
-#  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
-#  define BOOST_NO_EXTERN_TEMPLATE
-#  define BOOST_NO_RVALUE_REFERENCES 
-#  define BOOST_NO_SCOPED_ENUMS
-#  define BOOST_NO_STATIC_ASSERT
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#  define BOOST_NO_CXX11_DECLTYPE
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#  define BOOST_NO_CXX11_STATIC_ASSERT
 #else
 #  define BOOST_HAS_ALIGNOF
 #  define BOOST_HAS_CHAR16_T
 #  define BOOST_HAS_STATIC_ASSERT
 #endif
 
-#define BOOST_NO_AUTO_DECLARATIONS
-#define BOOST_NO_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CONCEPTS
-#define BOOST_NO_CONSTEXPR
-#define BOOST_NO_DEFAULTED_FUNCTIONS
-#define BOOST_NO_DELETED_FUNCTIONS
-#define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
-#define BOOST_NO_INITIALIZER_LISTS
-#define BOOST_NO_LAMBDAS
-#define BOOST_NO_NULLPTR
-#define BOOST_NO_RAW_LITERALS
-#define BOOST_NO_RVALUE_REFERENCES
-#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
-#define BOOST_NO_TEMPLATE_ALIASES
-#define BOOST_NO_UNICODE_LITERALS    // UTF-8 still not supported
-#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS    // UTF-8 still not supported
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
 
 #if __BORLANDC__ >= 0x590
 #  define BOOST_HAS_TR1_HASH
 // all versions support __declspec:
 //
 #if defined(__STRICT_ANSI__)
-// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined  
+// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
 #  define BOOST_SYMBOL_EXPORT
 #endif
 //
 #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 
 #define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)
-
-
-
index 85f4484..b57e26c 100644 (file)
 // (C) Copyright Douglas Gregor 2010
 //
-//  Use, modification and distribution are subject to the 
-//  Boost Software License, Version 1.0. (See accompanying file 
+//  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 for most recent version.
 
 // Clang compiler setup.
 
-#if __has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
-#else
+#define BOOST_HAS_PRAGMA_ONCE
+
+#if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
 
-#if __has_feature(cxx_rtti)
-#else
+#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_RTTI)
 #  define BOOST_NO_RTTI
 #endif
 
-#if defined(__int64)
+#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_TYPEID)
+#  define BOOST_NO_TYPEID
+#endif
+
+#if defined(__int64) && !defined(__GNUC__)
 #  define BOOST_HAS_MS_INT64
 #endif
 
 #define BOOST_HAS_NRVO
 
-// NOTE: Clang's C++0x support is not worth detecting. However, it
-// supports both extern templates and "long long" even in C++98/03
-// mode.
-#define BOOST_NO_AUTO_DECLARATIONS
-#define BOOST_NO_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CHAR16_T
-#define BOOST_NO_CHAR32_T
-#define BOOST_NO_CONCEPTS
-#define BOOST_NO_CONSTEXPR
-#define BOOST_NO_DECLTYPE
-#define BOOST_NO_DEFAULTED_FUNCTIONS
-#define BOOST_NO_DELETED_FUNCTIONS
-#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
-#define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
-#define BOOST_NO_INITIALIZER_LISTS
-#define BOOST_NO_LAMBDAS
-#define BOOST_NO_NULLPTR
-#define BOOST_NO_RAW_LITERALS
-#define BOOST_NO_RVALUE_REFERENCES
-#define BOOST_NO_SCOPED_ENUMS
-#define BOOST_NO_STATIC_ASSERT
-#define BOOST_NO_TEMPLATE_ALIASES
-#define BOOST_NO_UNICODE_LITERALS
-#define BOOST_NO_VARIADIC_TEMPLATES
-
-// HACK: Clang does support extern templates, but Boost's test for
-// them is wrong.
-#define BOOST_NO_EXTERN_TEMPLATE
+// Branch prediction hints
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_expect)
+#define BOOST_LIKELY(x) __builtin_expect(x, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
+#endif
+#endif
+
+// Clang supports "long long" in all compilation modes.
+#define BOOST_HAS_LONG_LONG
+
+//
+// Dynamic shared object (DSO) and dynamic-link library (DLL) support
+//
+#if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
+#  define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
+#  define BOOST_SYMBOL_IMPORT
+#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
+#endif
+
+//
+// The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through
+// between switch labels.
+//
+#if __cplusplus >= 201103L && defined(__has_warning)
+#  if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#    define BOOST_FALLTHROUGH [[clang::fallthrough]]
+#  endif
+#endif
+
+#if !__has_feature(cxx_auto_type)
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#endif
+
+#if !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#endif
+
+#if !__has_feature(cxx_constexpr)
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
+
+#if !__has_feature(cxx_decltype)
+#  define BOOST_NO_CXX11_DECLTYPE
+#endif
+
+#if !__has_feature(cxx_decltype_incomplete_return_types)
+#  define BOOST_NO_CXX11_DECLTYPE_N3276
+#endif
+
+#if !__has_feature(cxx_defaulted_functions)
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#endif
+
+#if !__has_feature(cxx_deleted_functions)
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#endif
+
+#if !__has_feature(cxx_explicit_conversions)
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#endif
+
+#if !__has_feature(cxx_default_function_template_args)
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+
+#if !__has_feature(cxx_generalized_initializers)
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#endif
+
+#if !__has_feature(cxx_lambdas)
+#  define BOOST_NO_CXX11_LAMBDAS
+#endif
+
+#if !__has_feature(cxx_local_type_template_args)
+#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#endif
+
+#if !__has_feature(cxx_noexcept)
+#  define BOOST_NO_CXX11_NOEXCEPT
+#endif
+
+#if !__has_feature(cxx_nullptr)
+#  define BOOST_NO_CXX11_NULLPTR
+#endif
+
+#if !__has_feature(cxx_range_for)
+#  define BOOST_NO_CXX11_RANGE_BASED_FOR
+#endif
+
+#if !__has_feature(cxx_raw_string_literals)
+#  define BOOST_NO_CXX11_RAW_LITERALS
+#endif
+
+#if !__has_feature(cxx_generalized_initializers)
+#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#endif
+
+#if !__has_feature(cxx_rvalue_references)
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+
+#if !__has_feature(cxx_strong_enums)
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+
+#if !__has_feature(cxx_static_assert)
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#endif
+
+#if !__has_feature(cxx_alias_templates)
+#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#endif
+
+#if !__has_feature(cxx_unicode_literals)
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+
+#if !__has_feature(cxx_variadic_templates)
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif
+
+#if !__has_feature(cxx_user_literals)
+#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#endif
+
+#if !(__has_feature(cxx_alignas) || __has_extension(cxx_alignas))
+#  define BOOST_NO_CXX11_ALIGNAS
+#endif
+
+#if !__has_feature(cxx_trailing_return)
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#endif
+
+#if !__has_feature(cxx_inline_namespaces)
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#endif
+
+// Clang always supports variadic macros
+// Clang always supports extern templates
 
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "Clang version " __clang_version__
index f6dc4c0..00e0bb9 100644 (file)
@@ -60,7 +60,7 @@
 // (Niels Dekker, LKEB, April 2010)
 #  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 
-#  ifdef NDEBUG
+#  if defined(NDEBUG) && defined(__cplusplus)
       // fix broken <cstring> so that Boost.test works:
 #     include <cstring>
 #     undef strcmp
 #  endif
 
 #endif
+
+// Reportedly, #pragma once is supported since C++ Builder 2010
+#if (__CODEGEARC__ >= 0x620)
+#  define BOOST_HAS_PRAGMA_ONCE
+#endif
+
 //
 // C++0x macros:
 //
 #if (__CODEGEARC__ <= 0x620)
-#define BOOST_NO_STATIC_ASSERT
+#define BOOST_NO_CXX11_STATIC_ASSERT
 #else
 #define BOOST_HAS_STATIC_ASSERT
 #endif
 // #define BOOST_HAS_STATIC_ASSERT
 #define BOOST_HAS_STD_TYPE_TRAITS
 
-#define BOOST_NO_AUTO_DECLARATIONS
-#define BOOST_NO_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CONCEPTS
-#define BOOST_NO_CONSTEXPR
-#define BOOST_NO_DEFAULTED_FUNCTIONS
-#define BOOST_NO_DELETED_FUNCTIONS
-#define BOOST_NO_EXTERN_TEMPLATE
-#define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
-#define BOOST_NO_INITIALIZER_LISTS
-#define BOOST_NO_LAMBDAS
-#define BOOST_NO_NULLPTR
-#define BOOST_NO_RAW_LITERALS
-#define BOOST_NO_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_SFINAE_EXPR
-#define BOOST_NO_TEMPLATE_ALIASES
-#define BOOST_NO_UNICODE_LITERALS
-#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
 
 //
 // TR1 macros:
 
 #define BOOST_HAS_MACRO_USE_FACET
 
-#define BOOST_NO_INITIALIZER_LISTS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
 
 // On non-Win32 platforms let the platform config figure this out:
 #ifdef _WIN32
 // all versions support __declspec:
 //
 #if defined(__STRICT_ANSI__)
-// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined  
+// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
 #  define BOOST_SYMBOL_EXPORT
 #endif
 //
index cb28337..70e7efa 100644 (file)
@@ -1,10 +1,10 @@
-//  (C) Copyright John Maddock 2001 - 2002. 
-//  (C) Copyright Jens Maurer 2001. 
-//  (C) Copyright David Abrahams 2002. 
-//  (C) Copyright Aleksey Gurtovoy 2002. 
+//  (C) Copyright John Maddock 2001 - 2002.
+//  (C) Copyright Jens Maurer 2001.
+//  (C) Copyright David Abrahams 2002.
+//  (C) Copyright Aleksey Gurtovoy 2002.
 //  (C) Copyright Markus Schoepflin 2005.
-//  Use, modification and distribution are subject to the 
-//  Boost Software License, Version 1.0. (See accompanying file 
+//  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 for most recent version.
 
 #if (__EDG_VERSION__ <= 244) && !defined(BOOST_NO_TEMPLATE_TEMPLATES)
 #   define BOOST_NO_TEMPLATE_TEMPLATES
-#endif 
+#endif
 
 #if (__EDG_VERSION__ < 300) && !defined(BOOST_NO_IS_ABSTRACT)
 #   define BOOST_NO_IS_ABSTRACT
-#endif 
+#endif
 
 #if (__EDG_VERSION__ <= 303) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
 #   define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
-#endif 
+#endif
 
 // See also kai.hpp which checks a Kai-specific symbol for EH
 # if !defined(__KCC) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
 #     define BOOST_NO_LONG_LONG
 # endif
 
+// Not sure what version was the first to support #pragma once, but
+// different EDG-based compilers (e.g. Intel) supported it for ages.
+// Add a proper version check if it causes problems.
+#define BOOST_HAS_PRAGMA_ONCE
+
 //
 // C++0x features
 //
 //   See above for BOOST_NO_LONG_LONG
 //
 #if (__EDG_VERSION__ < 310)
-#  define BOOST_NO_EXTERN_TEMPLATE
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
 #endif
-#if (__EDG_VERSION__ <= 310) || !defined(BOOST_STRICT_CONFIG)
+#if (__EDG_VERSION__ <= 310)
 // No support for initializer lists
-#  define BOOST_NO_INITIALIZER_LISTS
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#endif
+#if (__EDG_VERSION__ < 400)
+#  define BOOST_NO_CXX11_VARIADIC_MACROS
 #endif
 
-#define BOOST_NO_AUTO_DECLARATIONS
-#define BOOST_NO_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CHAR16_T
-#define BOOST_NO_CHAR32_T
-#define BOOST_NO_CONCEPTS
-#define BOOST_NO_CONSTEXPR
-#define BOOST_NO_DECLTYPE
-#define BOOST_NO_DEFAULTED_FUNCTIONS
-#define BOOST_NO_DELETED_FUNCTIONS
-#define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
-#define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
-#define BOOST_NO_LAMBDAS
-#define BOOST_NO_NULLPTR
-#define BOOST_NO_RAW_LITERALS
-#define BOOST_NO_RVALUE_REFERENCES
-#define BOOST_NO_SCOPED_ENUMS
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
-#define BOOST_NO_STATIC_ASSERT
-#define BOOST_NO_TEMPLATE_ALIASES
-#define BOOST_NO_UNICODE_LITERALS
-#define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
 
 #ifdef c_plusplus
 // EDG has "long long" in non-strict mode
 // However, some libraries have insufficient "long long" support
 // #define BOOST_HAS_LONG_LONG
 #endif
-
-
-
diff --git a/boost/config/compiler/cray.hpp b/boost/config/compiler/cray.hpp
new file mode 100644 (file)
index 0000000..3ce29f0
--- /dev/null
@@ -0,0 +1,65 @@
+//  (C) Copyright John Maddock 2011.
+//  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 for most recent version.
+
+//  Greenhills C compiler setup:
+
+#define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE)
+
+#if _RELEASE < 7
+#  error "Boost is not configured for Cray compilers prior to version 7, please try the configure script."
+#endif
+
+//
+// Check this is a recent EDG based compiler, otherwise we don't support it here:
+//
+#ifndef __EDG_VERSION__
+#  error "Unsupported Cray compiler, please try running the configure script."
+#endif
+
+#include "boost/config/compiler/common_edg.hpp"
+
+//
+// Cray peculiarities, probably version 7 specific:
+//
+#undef BOOST_NO_CXX11_AUTO_DECLARATIONS
+#undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_HAS_NRVO
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_HAS_NRVO
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_CONSTEXPR
+#defin