wellton/chromium
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade

Delete boost.

Ver Código-Fonte 
Review URL: http://codereview.chromium.org/150086

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@20159 0039d316-1c4b-4281-b951-d872f2087c98
Esse commit está contido em:
ajwong@chromium.org
2009-07-08 17:36:50 +00:00
pai 1e4f3dd795
commit 09a9315dd4
393 arquivos alterados com 0 adições e 34285 exclusões
Baixar Arquivo de Patch Baixar Arquivo de Diff Expandir todos os arquivos Colapsar todos os arquivos
testing/gmock.gyp
-10
Ver Arquivo
@@ -52,16 +52,6 @@
'export_dependent_settings': [
'gtest.gyp:gtest',
],
'conditions': [
['OS=="win"', {
'dependencies': [
'../third_party/boost/boost.gyp:boost_tuple',
],
'export_dependent_settings': [
'../third_party/boost/boost.gyp:boost_tuple',
]
}],
],
},
{
# Note that calling this "gmock_main" confuses the scons build,
third_party/boost/README.chromium
externo
-37
Ver Arquivo
@@ -1,37 +0,0 @@
This contains a stripped down version of TR1::Boost version 1.36.0. It
contains only the files required to use tr1::tuple in Visual Studio 2005.
All other files have been removed. The original packing of Boost tuple used
to create this version was taken from the googlemock project download page:
http://googlemock.googlecode.com/files/boost_tr1_tuple_1_36_0.zip
This code is released under the Boost Software License - Version 1.0. See
boost_1_36_0/LICENSE_1_0.txt for details.
Steps to reproduce stripped down package:
1) Download from
http://googlemock.googlecode.com/files/boost_tr1_tuple_1_36_0.zip
2) Unzip the package. This will create the boost_1_36_0 directory.
3) Create a .cpp file with one line:
#include <tuple>
4) Run this file through the Visual C++ preprocessor, making sure that the
same compiler options (/I, /D, etc) are the same as for the the rest
project, and that #{BOOST_ROOT}/boost/tr1/tr1;${BOOST_ROOT} are added
to the include path path. To get the preprocess output in Visual Studio,
select the .cpp file, go to Properties | C/C++ | Preprocessor, and set
"Generate Preprocessed File" to Yes.
*5) In the preprocessed file, find all header files referenced in the
boost_1_36_0 subdirectory.
6) For each file in the boost_1_36_0 directory, if it is not referenced in
the list produced in step 5, delete it.
The result should be 389 files, at about 2.4 megs. Adding in the
LICENSE_1_0.txt file brings the distribution to an even 390 files.
In comparison the full expansion of boost_tr1_tuple_1_36_0.zip is 1097 files
using 9.2 megs.
* For step 5, the following bash line helps generate a list of files:
cat file.i | grep "^#line" | grep boost_1_36_0 | \
tr -s ' ' | cut -d ' ' -f3 | tr -d \" | sort -u
third_party/boost/boost.gyp
externo
-423
Ver Arquivo
@@ -1,423 +0,0 @@
# Copyright (c) 2009 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
{
'includes': [
'../../build/common.gypi',
],
'targets': [
# This only has a target for windows.
],
'conditions': [
['OS=="win"', {
'targets': [
{
# Only VS2005 needs boost tuple. VS2008 SP1, and gcc on mac + linux
# include tr1. However, since we cannot differentiate between VS2008
# and VS2005 in gyp, we do our best by only enabling this target for
# OS=="win".
'target_name': 'boost_tuple',
'type': 'none',
'msvs_guid': 'FCC71A12-BC0A-49C6-9ED7-80331F8B4071',
'sources': [
"boost_1_36_0/boost/config.hpp",
"boost_1_36_0/boost/config/compiler/visualc.hpp",
"boost_1_36_0/boost/config/no_tr1/utility.hpp",
"boost_1_36_0/boost/config/platform/win32.hpp",
"boost_1_36_0/boost/config/select_compiler_config.hpp",
"boost_1_36_0/boost/config/select_platform_config.hpp",
"boost_1_36_0/boost/config/select_stdlib_config.hpp",
"boost_1_36_0/boost/config/stdlib/dinkumware.hpp",
"boost_1_36_0/boost/config/suffix.hpp",
"boost_1_36_0/boost/config/user.hpp",
"boost_1_36_0/boost/detail/workaround.hpp",
"boost_1_36_0/boost/fusion/adapted/std_pair.hpp",
"boost_1_36_0/boost/fusion/adapted/struct.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/adapt_assoc_struct.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/adapt_struct.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/at_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/at_key_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/begin_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/category_of_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/end_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/has_key_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/is_view_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/size_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/value_at_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/detail/value_at_key_impl.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/extension.hpp",
"boost_1_36_0/boost/fusion/adapted/struct/struct_iterator.hpp",
"boost_1_36_0/boost/fusion/container/generation/ignore.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/advance_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/at_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/begin_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/deref_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/distance_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/end_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/equal_to_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/next_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/prior_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/value_at_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/value_of_impl.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/vector_forward_ctor.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/vector_n.hpp",
"boost_1_36_0/boost/fusion/container/vector/detail/vector_n_chooser.hpp",
"boost_1_36_0/boost/fusion/container/vector/limits.hpp",
"boost_1_36_0/boost/fusion/container/vector/vector.hpp",
"boost_1_36_0/boost/fusion/container/vector/vector10.hpp",
"boost_1_36_0/boost/fusion/container/vector/vector_fwd.hpp",
"boost_1_36_0/boost/fusion/container/vector/vector_iterator.hpp",
"boost_1_36_0/boost/fusion/include/std_pair.hpp",
"boost_1_36_0/boost/fusion/include/tuple.hpp",
"boost_1_36_0/boost/fusion/iterator/deref.hpp",
"boost_1_36_0/boost/fusion/iterator/detail/advance.hpp",
"boost_1_36_0/boost/fusion/iterator/equal_to.hpp",
"boost_1_36_0/boost/fusion/iterator/iterator_facade.hpp",
"boost_1_36_0/boost/fusion/iterator/next.hpp",
"boost_1_36_0/boost/fusion/iterator/prior.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/detail/enable_comparison.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/detail/equal_to.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/detail/less.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/equal_to.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/greater.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/greater_equal.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/less.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/less_equal.hpp",
"boost_1_36_0/boost/fusion/sequence/comparison/not_equal_to.hpp",
"boost_1_36_0/boost/fusion/sequence/intrinsic/at.hpp",
"boost_1_36_0/boost/fusion/sequence/intrinsic/begin.hpp",
"boost_1_36_0/boost/fusion/sequence/intrinsic/end.hpp",
"boost_1_36_0/boost/fusion/sequence/intrinsic/size.hpp",
"boost_1_36_0/boost/fusion/sequence/intrinsic/value_at.hpp",
"boost_1_36_0/boost/fusion/sequence/io.hpp",
"boost_1_36_0/boost/fusion/sequence/io/detail/in.hpp",
"boost_1_36_0/boost/fusion/sequence/io/detail/manip.hpp",
"boost_1_36_0/boost/fusion/sequence/io/detail/out.hpp",
"boost_1_36_0/boost/fusion/sequence/io/in.hpp",
"boost_1_36_0/boost/fusion/sequence/io/out.hpp",
"boost_1_36_0/boost/fusion/support/category_of.hpp",
"boost_1_36_0/boost/fusion/support/detail/access.hpp",
"boost_1_36_0/boost/fusion/support/detail/as_fusion_element.hpp",
"boost_1_36_0/boost/fusion/support/detail/category_of.hpp",
"boost_1_36_0/boost/fusion/support/detail/is_mpl_sequence.hpp",
"boost_1_36_0/boost/fusion/support/is_iterator.hpp",
"boost_1_36_0/boost/fusion/support/is_sequence.hpp",
"boost_1_36_0/boost/fusion/support/iterator_base.hpp",
"boost_1_36_0/boost/fusion/support/sequence_base.hpp",
"boost_1_36_0/boost/fusion/support/tag_of.hpp",
"boost_1_36_0/boost/fusion/support/tag_of_fwd.hpp",
"boost_1_36_0/boost/fusion/tuple.hpp",
"boost_1_36_0/boost/fusion/tuple/detail/tuple_forward_ctor.hpp",
"boost_1_36_0/boost/fusion/tuple/make_tuple.hpp",
"boost_1_36_0/boost/fusion/tuple/tuple.hpp",
"boost_1_36_0/boost/fusion/tuple/tuple_fwd.hpp",
"boost_1_36_0/boost/fusion/tuple/tuple_tie.hpp",
"boost_1_36_0/boost/mpl/advance.hpp",
"boost_1_36_0/boost/mpl/advance_fwd.hpp",
"boost_1_36_0/boost/mpl/always.hpp",
"boost_1_36_0/boost/mpl/and.hpp",
"boost_1_36_0/boost/mpl/apply.hpp",
"boost_1_36_0/boost/mpl/apply_fwd.hpp",
"boost_1_36_0/boost/mpl/apply_wrap.hpp",
"boost_1_36_0/boost/mpl/arg.hpp",
"boost_1_36_0/boost/mpl/arg_fwd.hpp",
"boost_1_36_0/boost/mpl/assert.hpp",
"boost_1_36_0/boost/mpl/at.hpp",
"boost_1_36_0/boost/mpl/at_fwd.hpp",
"boost_1_36_0/boost/mpl/aux_/adl_barrier.hpp",
"boost_1_36_0/boost/mpl/aux_/advance_backward.hpp",
"boost_1_36_0/boost/mpl/aux_/advance_forward.hpp",
"boost_1_36_0/boost/mpl/aux_/arg_typedef.hpp",
"boost_1_36_0/boost/mpl/aux_/arithmetic_op.hpp",
"boost_1_36_0/boost/mpl/aux_/arity.hpp",
"boost_1_36_0/boost/mpl/aux_/arity_spec.hpp",
"boost_1_36_0/boost/mpl/aux_/at_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/begin_end_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/common_name_wknd.hpp",
"boost_1_36_0/boost/mpl/aux_/comparison_op.hpp",
"boost_1_36_0/boost/mpl/aux_/config/adl.hpp",
"boost_1_36_0/boost/mpl/aux_/config/arrays.hpp",
"boost_1_36_0/boost/mpl/aux_/config/bind.hpp",
"boost_1_36_0/boost/mpl/aux_/config/compiler.hpp",
"boost_1_36_0/boost/mpl/aux_/config/ctps.hpp",
"boost_1_36_0/boost/mpl/aux_/config/dtp.hpp",
"boost_1_36_0/boost/mpl/aux_/config/eti.hpp",
"boost_1_36_0/boost/mpl/aux_/config/forwarding.hpp",
"boost_1_36_0/boost/mpl/aux_/config/gcc.hpp",
"boost_1_36_0/boost/mpl/aux_/config/has_apply.hpp",
"boost_1_36_0/boost/mpl/aux_/config/has_xxx.hpp",
"boost_1_36_0/boost/mpl/aux_/config/integral.hpp",
"boost_1_36_0/boost/mpl/aux_/config/intel.hpp",
"boost_1_36_0/boost/mpl/aux_/config/lambda.hpp",
"boost_1_36_0/boost/mpl/aux_/config/msvc.hpp",
"boost_1_36_0/boost/mpl/aux_/config/msvc_typename.hpp",
"boost_1_36_0/boost/mpl/aux_/config/nttp.hpp",
"boost_1_36_0/boost/mpl/aux_/config/overload_resolution.hpp",
"boost_1_36_0/boost/mpl/aux_/config/pp_counter.hpp",
"boost_1_36_0/boost/mpl/aux_/config/preprocessor.hpp",
"boost_1_36_0/boost/mpl/aux_/config/static_constant.hpp",
"boost_1_36_0/boost/mpl/aux_/config/ttp.hpp",
"boost_1_36_0/boost/mpl/aux_/config/typeof.hpp",
"boost_1_36_0/boost/mpl/aux_/config/use_preprocessed.hpp",
"boost_1_36_0/boost/mpl/aux_/config/workaround.hpp",
"boost_1_36_0/boost/mpl/aux_/find_if_pred.hpp",
"boost_1_36_0/boost/mpl/aux_/full_lambda.hpp",
"boost_1_36_0/boost/mpl/aux_/has_apply.hpp",
"boost_1_36_0/boost/mpl/aux_/has_begin.hpp",
"boost_1_36_0/boost/mpl/aux_/has_size.hpp",
"boost_1_36_0/boost/mpl/aux_/has_tag.hpp",
"boost_1_36_0/boost/mpl/aux_/has_type.hpp",
"boost_1_36_0/boost/mpl/aux_/include_preprocessed.hpp",
"boost_1_36_0/boost/mpl/aux_/integral_wrapper.hpp",
"boost_1_36_0/boost/mpl/aux_/is_msvc_eti_arg.hpp",
"boost_1_36_0/boost/mpl/aux_/iter_apply.hpp",
"boost_1_36_0/boost/mpl/aux_/iter_fold_if_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/iter_fold_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/lambda_arity_param.hpp",
"boost_1_36_0/boost/mpl/aux_/lambda_spec.hpp",
"boost_1_36_0/boost/mpl/aux_/lambda_support.hpp",
"boost_1_36_0/boost/mpl/aux_/largest_int.hpp",
"boost_1_36_0/boost/mpl/aux_/msvc_eti_base.hpp",
"boost_1_36_0/boost/mpl/aux_/msvc_never_true.hpp",
"boost_1_36_0/boost/mpl/aux_/msvc_type.hpp",
"boost_1_36_0/boost/mpl/aux_/na.hpp",
"boost_1_36_0/boost/mpl/aux_/na_assert.hpp",
"boost_1_36_0/boost/mpl/aux_/na_fwd.hpp",
"boost_1_36_0/boost/mpl/aux_/na_spec.hpp",
"boost_1_36_0/boost/mpl/aux_/nested_type_wknd.hpp",
"boost_1_36_0/boost/mpl/aux_/nttp_decl.hpp",
"boost_1_36_0/boost/mpl/aux_/numeric_cast_utils.hpp",
"boost_1_36_0/boost/mpl/aux_/numeric_op.hpp",
"boost_1_36_0/boost/mpl/aux_/o1_size_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/and.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/apply.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/arg.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/bind.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/equal_to.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/less.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/minus.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/or.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/placeholders.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/plus.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/quote.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessed/plain/template_arity.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessor/def_params_tail.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessor/enum.hpp",
"boost_1_36_0/boost/mpl/aux_/preprocessor/params.hpp",
"boost_1_36_0/boost/mpl/aux_/static_cast.hpp",
"boost_1_36_0/boost/mpl/aux_/template_arity.hpp",
"boost_1_36_0/boost/mpl/aux_/template_arity_fwd.hpp",
"boost_1_36_0/boost/mpl/aux_/traits_lambda_spec.hpp",
"boost_1_36_0/boost/mpl/aux_/type_wrapper.hpp",
"boost_1_36_0/boost/mpl/aux_/value_wknd.hpp",
"boost_1_36_0/boost/mpl/aux_/yes_no.hpp",
"boost_1_36_0/boost/mpl/back_fwd.hpp",
"boost_1_36_0/boost/mpl/begin_end.hpp",
"boost_1_36_0/boost/mpl/begin_end_fwd.hpp",
"boost_1_36_0/boost/mpl/bind.hpp",
"boost_1_36_0/boost/mpl/bind_fwd.hpp",
"boost_1_36_0/boost/mpl/bool.hpp",
"boost_1_36_0/boost/mpl/bool_fwd.hpp",
"boost_1_36_0/boost/mpl/clear_fwd.hpp",
"boost_1_36_0/boost/mpl/deref.hpp",
"boost_1_36_0/boost/mpl/distance.hpp",
"boost_1_36_0/boost/mpl/distance_fwd.hpp",
"boost_1_36_0/boost/mpl/empty_fwd.hpp",
"boost_1_36_0/boost/mpl/equal_to.hpp",
"boost_1_36_0/boost/mpl/eval_if.hpp",
"boost_1_36_0/boost/mpl/find.hpp",
"boost_1_36_0/boost/mpl/find_if.hpp",
"boost_1_36_0/boost/mpl/front_fwd.hpp",
"boost_1_36_0/boost/mpl/has_xxx.hpp",
"boost_1_36_0/boost/mpl/identity.hpp",
"boost_1_36_0/boost/mpl/if.hpp",
"boost_1_36_0/boost/mpl/int.hpp",
"boost_1_36_0/boost/mpl/int_fwd.hpp",
"boost_1_36_0/boost/mpl/integral_c.hpp",
"boost_1_36_0/boost/mpl/integral_c_fwd.hpp",
"boost_1_36_0/boost/mpl/integral_c_tag.hpp",
"boost_1_36_0/boost/mpl/is_sequence.hpp",
"boost_1_36_0/boost/mpl/iter_fold.hpp",
"boost_1_36_0/boost/mpl/iter_fold_if.hpp",
"boost_1_36_0/boost/mpl/iterator_range.hpp",
"boost_1_36_0/boost/mpl/iterator_tags.hpp",
"boost_1_36_0/boost/mpl/lambda.hpp",
"boost_1_36_0/boost/mpl/lambda_fwd.hpp",
"boost_1_36_0/boost/mpl/less.hpp",
"boost_1_36_0/boost/mpl/limits/arity.hpp",
"boost_1_36_0/boost/mpl/logical.hpp",
"boost_1_36_0/boost/mpl/long.hpp",
"boost_1_36_0/boost/mpl/long_fwd.hpp",
"boost_1_36_0/boost/mpl/minus.hpp",
"boost_1_36_0/boost/mpl/negate.hpp",
"boost_1_36_0/boost/mpl/next.hpp",
"boost_1_36_0/boost/mpl/next_prior.hpp",
"boost_1_36_0/boost/mpl/not.hpp",
"boost_1_36_0/boost/mpl/numeric_cast.hpp",
"boost_1_36_0/boost/mpl/o1_size.hpp",
"boost_1_36_0/boost/mpl/o1_size_fwd.hpp",
"boost_1_36_0/boost/mpl/or.hpp",
"boost_1_36_0/boost/mpl/pair.hpp",
"boost_1_36_0/boost/mpl/placeholders.hpp",
"boost_1_36_0/boost/mpl/plus.hpp",
"boost_1_36_0/boost/mpl/pop_back_fwd.hpp",
"boost_1_36_0/boost/mpl/pop_front_fwd.hpp",
"boost_1_36_0/boost/mpl/prior.hpp",
"boost_1_36_0/boost/mpl/protect.hpp",
"boost_1_36_0/boost/mpl/push_back_fwd.hpp",
"boost_1_36_0/boost/mpl/push_front_fwd.hpp",
"boost_1_36_0/boost/mpl/quote.hpp",
"boost_1_36_0/boost/mpl/same_as.hpp",
"boost_1_36_0/boost/mpl/sequence_tag.hpp",
"boost_1_36_0/boost/mpl/sequence_tag_fwd.hpp",
"boost_1_36_0/boost/mpl/size_fwd.hpp",
"boost_1_36_0/boost/mpl/tag.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/at.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/back.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/begin_end.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/clear.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/empty.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/front.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/include_preprocessed.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/item.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/iterator.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/o1_size.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/pop_back.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/pop_front.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/push_back.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/push_front.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/size.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/tag.hpp",
"boost_1_36_0/boost/mpl/vector/aux_/vector0.hpp",
"boost_1_36_0/boost/mpl/vector/vector0.hpp",
"boost_1_36_0/boost/mpl/vector/vector10.hpp",
"boost_1_36_0/boost/mpl/void.hpp",
"boost_1_36_0/boost/mpl/void_fwd.hpp",
"boost_1_36_0/boost/preprocessor/arithmetic/add.hpp",
"boost_1_36_0/boost/preprocessor/arithmetic/dec.hpp",
"boost_1_36_0/boost/preprocessor/arithmetic/inc.hpp",
"boost_1_36_0/boost/preprocessor/arithmetic/sub.hpp",
"boost_1_36_0/boost/preprocessor/array/data.hpp",
"boost_1_36_0/boost/preprocessor/array/elem.hpp",
"boost_1_36_0/boost/preprocessor/array/size.hpp",
"boost_1_36_0/boost/preprocessor/cat.hpp",
"boost_1_36_0/boost/preprocessor/comma_if.hpp",
"boost_1_36_0/boost/preprocessor/config/config.hpp",
"boost_1_36_0/boost/preprocessor/control/detail/msvc/while.hpp",
"boost_1_36_0/boost/preprocessor/control/expr_iif.hpp",
"boost_1_36_0/boost/preprocessor/control/if.hpp",
"boost_1_36_0/boost/preprocessor/control/iif.hpp",
"boost_1_36_0/boost/preprocessor/control/while.hpp",
"boost_1_36_0/boost/preprocessor/debug/error.hpp",
"boost_1_36_0/boost/preprocessor/dec.hpp",
"boost_1_36_0/boost/preprocessor/detail/auto_rec.hpp",
"boost_1_36_0/boost/preprocessor/detail/check.hpp",
"boost_1_36_0/boost/preprocessor/detail/is_binary.hpp",
"boost_1_36_0/boost/preprocessor/empty.hpp",
"boost_1_36_0/boost/preprocessor/facilities/empty.hpp",
"boost_1_36_0/boost/preprocessor/facilities/identity.hpp",
"boost_1_36_0/boost/preprocessor/facilities/intercept.hpp",
"boost_1_36_0/boost/preprocessor/identity.hpp",
"boost_1_36_0/boost/preprocessor/inc.hpp",
"boost_1_36_0/boost/preprocessor/iterate.hpp",
"boost_1_36_0/boost/preprocessor/iteration/detail/bounds/lower1.hpp",
"boost_1_36_0/boost/preprocessor/iteration/detail/bounds/upper1.hpp",
"boost_1_36_0/boost/preprocessor/iteration/detail/iter/forward1.hpp",
"boost_1_36_0/boost/preprocessor/iteration/iterate.hpp",
"boost_1_36_0/boost/preprocessor/list/adt.hpp",
"boost_1_36_0/boost/preprocessor/list/detail/fold_left.hpp",
"boost_1_36_0/boost/preprocessor/list/detail/fold_right.hpp",
"boost_1_36_0/boost/preprocessor/list/fold_left.hpp",
"boost_1_36_0/boost/preprocessor/list/fold_right.hpp",
"boost_1_36_0/boost/preprocessor/list/reverse.hpp",
"boost_1_36_0/boost/preprocessor/logical/and.hpp",
"boost_1_36_0/boost/preprocessor/logical/bitand.hpp",
"boost_1_36_0/boost/preprocessor/logical/bool.hpp",
"boost_1_36_0/boost/preprocessor/logical/compl.hpp",
"boost_1_36_0/boost/preprocessor/punctuation/comma.hpp",
"boost_1_36_0/boost/preprocessor/punctuation/comma_if.hpp",
"boost_1_36_0/boost/preprocessor/repeat.hpp",
"boost_1_36_0/boost/preprocessor/repetition/detail/msvc/for.hpp",
"boost_1_36_0/boost/preprocessor/repetition/enum.hpp",
"boost_1_36_0/boost/preprocessor/repetition/enum_binary_params.hpp",
"boost_1_36_0/boost/preprocessor/repetition/enum_params.hpp",
"boost_1_36_0/boost/preprocessor/repetition/enum_params_with_a_default.hpp",
"boost_1_36_0/boost/preprocessor/repetition/enum_shifted.hpp",
"boost_1_36_0/boost/preprocessor/repetition/for.hpp",
"boost_1_36_0/boost/preprocessor/repetition/repeat.hpp",
"boost_1_36_0/boost/preprocessor/repetition/repeat_from_to.hpp",
"boost_1_36_0/boost/preprocessor/seq/elem.hpp",
"boost_1_36_0/boost/preprocessor/seq/for_each_i.hpp",
"boost_1_36_0/boost/preprocessor/seq/seq.hpp",
"boost_1_36_0/boost/preprocessor/seq/size.hpp",
"boost_1_36_0/boost/preprocessor/slot/detail/def.hpp",
"boost_1_36_0/boost/preprocessor/slot/detail/shared.hpp",
"boost_1_36_0/boost/preprocessor/slot/slot.hpp",
"boost_1_36_0/boost/preprocessor/stringize.hpp",
"boost_1_36_0/boost/preprocessor/tuple/eat.hpp",
"boost_1_36_0/boost/preprocessor/tuple/elem.hpp",
"boost_1_36_0/boost/preprocessor/tuple/rem.hpp",
"boost_1_36_0/boost/ref.hpp",
"boost_1_36_0/boost/static_assert.hpp",
"boost_1_36_0/boost/tr1/detail/config.hpp",
"boost_1_36_0/boost/tr1/detail/config_all.hpp",
"boost_1_36_0/boost/tr1/tr1/tuple",
"boost_1_36_0/boost/tr1/tuple.hpp",
"boost_1_36_0/boost/type_traits/add_const.hpp",
"boost_1_36_0/boost/type_traits/add_reference.hpp",
"boost_1_36_0/boost/type_traits/broken_compiler_spec.hpp",
"boost_1_36_0/boost/type_traits/config.hpp",
"boost_1_36_0/boost/type_traits/detail/bool_trait_def.hpp",
"boost_1_36_0/boost/type_traits/detail/bool_trait_undef.hpp",
"boost_1_36_0/boost/type_traits/detail/cv_traits_impl.hpp",
"boost_1_36_0/boost/type_traits/detail/ice_and.hpp",
"boost_1_36_0/boost/type_traits/detail/ice_eq.hpp",
"boost_1_36_0/boost/type_traits/detail/ice_not.hpp",
"boost_1_36_0/boost/type_traits/detail/ice_or.hpp",
"boost_1_36_0/boost/type_traits/detail/template_arity_spec.hpp",
"boost_1_36_0/boost/type_traits/detail/type_trait_def.hpp",
"boost_1_36_0/boost/type_traits/detail/type_trait_undef.hpp",
"boost_1_36_0/boost/type_traits/detail/yes_no_type.hpp",
"boost_1_36_0/boost/type_traits/ice.hpp",
"boost_1_36_0/boost/type_traits/integral_constant.hpp",
"boost_1_36_0/boost/type_traits/intrinsics.hpp",
"boost_1_36_0/boost/type_traits/is_abstract.hpp",
"boost_1_36_0/boost/type_traits/is_arithmetic.hpp",
"boost_1_36_0/boost/type_traits/is_array.hpp",
"boost_1_36_0/boost/type_traits/is_base_and_derived.hpp",
"boost_1_36_0/boost/type_traits/is_base_of.hpp",
"boost_1_36_0/boost/type_traits/is_const.hpp",
"boost_1_36_0/boost/type_traits/is_convertible.hpp",
"boost_1_36_0/boost/type_traits/is_float.hpp",
"boost_1_36_0/boost/type_traits/is_integral.hpp",
"boost_1_36_0/boost/type_traits/is_reference.hpp",
"boost_1_36_0/boost/type_traits/is_same.hpp",
"boost_1_36_0/boost/type_traits/is_void.hpp",
"boost_1_36_0/boost/type_traits/is_volatile.hpp",
"boost_1_36_0/boost/type_traits/remove_const.hpp",
"boost_1_36_0/boost/type_traits/remove_cv.hpp",
"boost_1_36_0/boost/utility/addressof.hpp",
"boost_1_36_0/boost/utility/enable_if.hpp",
],
'direct_dependent_settings': {
'include_dirs': [
'boost_1_36_0',
],
},
}
],
}],
],
}
third_party/boost/boost_1_36_0/LICENSE_1_0.txt
externo
-23
Ver Arquivo
@@ -1,23 +0,0 @@
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
third_party/boost/boost_1_36_0/boost/config.hpp
externo
-70
Ver Arquivo
@@ -1,70 +0,0 @@
// Boost config.hpp configuration header file ------------------------------//
// (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)
// See http://www.boost.org/libs/config for most recent version.
// Boost config.hpp policy and rationale documentation has been moved to
// http://www.boost.org/libs/config
//
// CAUTION: This file is intended to be completely stable -
// DO NOT MODIFY THIS FILE!
//
#ifndef BOOST_CONFIG_HPP
#define BOOST_CONFIG_HPP
// if we don't have a user config, then use the default location:
#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG)
# define BOOST_USER_CONFIG <boost/config/user.hpp>
#endif
// include it first:
#ifdef BOOST_USER_CONFIG
# include BOOST_USER_CONFIG
#endif
// if we don't have a compiler config set, try and find one:
#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG)
# include <boost/config/select_compiler_config.hpp>
#endif
// if we have a compiler config, include it now:
#ifdef BOOST_COMPILER_CONFIG
# include BOOST_COMPILER_CONFIG
#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)
# include <boost/config/select_stdlib_config.hpp>
#endif
// if we have a std library config, include it now:
#ifdef BOOST_STDLIB_CONFIG
# include BOOST_STDLIB_CONFIG
#endif
// if we don't have a platform config set, try and find one:
#if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG)
# include <boost/config/select_platform_config.hpp>
#endif
// if we have a platform config, include it now:
#ifdef BOOST_PLATFORM_CONFIG
# include BOOST_PLATFORM_CONFIG
#endif
// get config suffix code:
#include <boost/config/suffix.hpp>
#endif // BOOST_CONFIG_HPP
third_party/boost/boost_1_36_0/boost/config/compiler/visualc.hpp
externo
-196
Ver Arquivo
@@ -1,196 +0,0 @@
// (C) Copyright John Maddock 2001 - 2003.
// (C) Copyright Darin Adler 2001 - 2002.
// (C) Copyright Peter Dimov 2001.
// (C) Copyright Aleksey Gurtovoy 2002.
// (C) Copyright David Abrahams 2002 - 2003.
// (C) Copyright Beman Dawes 2002 - 2003.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for most recent version.
// Microsoft Visual C++ compiler setup:
#define BOOST_MSVC _MSC_VER
// turn off the warnings before we #include anything
#pragma warning( disable : 4503 ) // warning: decorated name length exceeded
#if _MSC_VER < 1300 // 1200 == VC++ 6.0, 1200-1202 == eVC++4
# pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info
# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
# define BOOST_NO_VOID_RETURNS
# define BOOST_NO_EXCEPTION_STD_NAMESPACE
// disable min/max macro defines on vc6:
//
#endif
#if (_MSC_VER <= 1300) // 1300 == VC++ 7.0
# if !defined(_MSC_EXTENSIONS) && !defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) // VC7 bug with /Za
# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
# endif
# define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
# define BOOST_NO_PRIVATE_IN_AGGREGATE
# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
# define BOOST_NO_INTEGRAL_INT64_T
# define BOOST_NO_DEDUCED_TYPENAME
# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
// VC++ 6/7 has member templates but they have numerous problems including
// cases of silent failure, so for safety we define:
# define BOOST_NO_MEMBER_TEMPLATES
// For VC++ experts wishing to attempt workarounds, we define:
# define BOOST_MSVC6_MEMBER_TEMPLATES
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# define BOOST_NO_CV_VOID_SPECIALIZATIONS
# define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
# define BOOST_NO_USING_TEMPLATE
# define BOOST_NO_SWPRINTF
# define BOOST_NO_TEMPLATE_TEMPLATES
# define BOOST_NO_SFINAE
# define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
# define BOOST_NO_IS_ABSTRACT
# define BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
// TODO: what version is meant here? Have there really been any fixes in cl 12.01 (as e.g. shipped with eVC4)?
# if (_MSC_VER > 1200)
# define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
# endif
#endif
#if _MSC_VER < 1400
// although a conforming signature for swprint exists in VC7.1
// it appears not to actually work:
# define BOOST_NO_SWPRINTF
#endif
#if defined(UNDER_CE)
// Windows CE does not have a conforming signature for swprintf
# define BOOST_NO_SWPRINTF
#endif
#if _MSC_VER <= 1400 // 1400 == VC++ 8.0
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#endif
#if _MSC_VER <= 1500 // 1500 == VC++ 9.0
# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif
#if _MSC_VER == 1500 // 1500 == VC++ 9.0
// A bug in VC9:
# define BOOST_NO_ADL_BARRIER
#endif
#ifndef _NATIVE_WCHAR_T_DEFINED
# define BOOST_NO_INTRINSIC_WCHAR_T
#endif
#if defined(_WIN32_WCE) || defined(UNDER_CE)
# define BOOST_NO_THREADEX
# define BOOST_NO_GETSYSTEMTIMEASFILETIME
# define BOOST_NO_SWPRINTF
#endif
//
// check for exception handling support:
#ifndef _CPPUNWIND
# define BOOST_NO_EXCEPTIONS
#endif
//
// __int64 support:
//
#if (_MSC_VER >= 1200)
# define BOOST_HAS_MS_INT64
#endif
#if (_MSC_VER >= 1310) && defined(_MSC_EXTENSIONS)
# define BOOST_HAS_LONG_LONG
#endif
#if (_MSC_VER >= 1400) && !defined(_DEBUG)
# define BOOST_HAS_NRVO
#endif
//
// disable Win32 API's if compiler extentions are
// turned off:
//
#ifndef _MSC_EXTENSIONS
# define BOOST_DISABLE_WIN32
#endif
//
// all versions support __declspec:
//
#define BOOST_HAS_DECLSPEC
//
// prefix and suffix headers:
//
#ifndef BOOST_ABI_PREFIX
# define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp"
#endif
#ifndef BOOST_ABI_SUFFIX
# define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp"
#endif
// TODO:
// these things are mostly bogus. 1200 means version 12.0 of the compiler. The
// artificial versions assigned to them only refer to the versions of some IDE
// these compilers have been shipped with, and even that is not all of it. Some
// were shipped with freely downloadable SDKs, others as crosscompilers in eVC.
// IOW, you can't use these 'versions' in any sensible way. Sorry.
# if defined(UNDER_CE)
# if _MSC_VER < 1200
// Note: these are so far off, they are not really supported
# elif _MSC_VER < 1300 // eVC++ 4 comes with 1200-1202
# define BOOST_COMPILER_VERSION evc4.0
# elif _MSC_VER == 1400
# define BOOST_COMPILER_VERSION evc8
# else
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown EVC++ compiler version - please run the configure tests and report the results"
# else
# pragma message("Unknown EVC++ compiler version - please run the configure tests and report the results")
# endif
# endif
# else
# if _MSC_VER < 1200
// Note: these are so far off, they are not really supported
# define BOOST_COMPILER_VERSION 5.0
# elif _MSC_VER < 1300
# define BOOST_COMPILER_VERSION 6.0
# elif _MSC_VER == 1300
# define BOOST_COMPILER_VERSION 7.0
# elif _MSC_VER == 1310
# define BOOST_COMPILER_VERSION 7.1
# elif _MSC_VER == 1400
# define BOOST_COMPILER_VERSION 8.0
# elif _MSC_VER == 1500
# define BOOST_COMPILER_VERSION 9.0
# else
# define BOOST_COMPILER_VERSION _MSC_VER
# endif
# endif
#define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
//
// versions check:
// we don't support Visual C++ prior to version 6:
#if _MSC_VER < 1200
#error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version is 1500 (VC9):
#if (_MSC_VER > 1500)
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
# else
# pragma message("Unknown compiler version - please run the configure tests and report the results")
# endif
#endif
third_party/boost/boost_1_36_0/boost/config/no_tr1/utility.hpp
externo
-28
Ver Arquivo
@@ -1,28 +0,0 @@
// (C) Copyright John Maddock 2005.
// 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)
//
// The aim of this header is just to include <utility> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/utility is in the
// include search path. We have to do this to avoid circular
// dependencies:
//
#ifndef BOOST_CONFIG_UTILITY
# define BOOST_CONFIG_UTILITY
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_CONFIG_NO_UTILITY_RECURSION
# endif
# include <utility>
# ifdef BOOST_CONFIG_NO_UTILITY_RECURSION
# undef BOOST_TR1_NO_RECURSION
# undef BOOST_CONFIG_NO_UTILITY_RECURSION
# endif
#endif
third_party/boost/boost_1_36_0/boost/config/platform/win32.hpp
externo
-58
Ver Arquivo
@@ -1,58 +0,0 @@
// (C) Copyright John Maddock 2001 - 2003.
// (C) Copyright Bill Kempf 2001.
// (C) Copyright Aleksey Gurtovoy 2003.
// (C) Copyright Rene Rivera 2005.
// 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.
// Win32 specific config options:
#define BOOST_PLATFORM "Win32"
// Get the information about the MinGW runtime, i.e. __MINGW32_*VERSION.
#if defined(__MINGW32__)
# include <_mingw.h>
#endif
#if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF)
# define BOOST_NO_SWPRINTF
#endif
#if !defined(__GNUC__) && !defined(BOOST_HAS_DECLSPEC)
# define BOOST_HAS_DECLSPEC
#endif
#if defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 2) || ((__MINGW32_MAJOR_VERSION == 2) && (__MINGW32_MINOR_VERSION >= 0)))
# define BOOST_HAS_STDINT_H
# define __STDC_LIMIT_MACROS
# define BOOST_HAS_DIRENT_H
# define BOOST_HAS_UNISTD_H
#endif
//
// Win32 will normally be using native Win32 threads,
// but there is a pthread library avaliable as an option,
// we used to disable this when BOOST_DISABLE_WIN32 was
// defined but no longer - this should allow some
// files to be compiled in strict mode - while maintaining
// a consistent setting of BOOST_HAS_THREADS across
// all translation units (needed for shared_ptr etc).
//
#ifdef _WIN32_WCE
# define BOOST_NO_ANSI_APIS
#endif
#ifndef BOOST_HAS_PTHREADS
# define BOOST_HAS_WINTHREADS
#endif
#ifndef BOOST_DISABLE_WIN32
// WEK: Added
#define BOOST_HAS_FTIME
#define BOOST_WINDOWS 1
#endif
third_party/boost/boost_1_36_0/boost/config/select_compiler_config.hpp
externo
-115
Ver Arquivo
@@ -1,115 +0,0 @@
// Boost compiler configuration selection header file
// (C) Copyright John Maddock 2001 - 2003.
// (C) Copyright Martin Wille 2003.
// (C) Copyright Guillaume Melquiond 2003.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/ for most recent version.
// one identification macro for each of the
// compilers we support:
# define BOOST_CXX_GCCXML 0
# define BOOST_CXX_COMO 0
# define BOOST_CXX_DMC 0
# define BOOST_CXX_INTEL 0
# define BOOST_CXX_GNUC 0
# define BOOST_CXX_KCC 0
# define BOOST_CXX_SGI 0
# define BOOST_CXX_TRU64 0
# define BOOST_CXX_GHS 0
# define BOOST_CXX_BORLAND 0
# define BOOST_CXX_CW 0
# define BOOST_CXX_SUNPRO 0
# define BOOST_CXX_HPACC 0
# define BOOST_CXX_MPW 0
# define BOOST_CXX_IBMCPP 0
# define BOOST_CXX_MSVC 0
# define BOOST_CXX_PGI 0
// locate which compiler we are using and define
// BOOST_COMPILER_CONFIG as needed:
#if defined(__GCCXML__)
// GCC-XML emulates other compilers, it has to appear first here!
# define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc_xml.hpp"
#elif defined __COMO__
// Comeau C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp"
#elif defined __DMC__
// Digital Mars C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp"
#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
// Intel
# define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"
# elif defined __GNUC__
// GNU C++:
# define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
#elif defined __KCC
// Kai C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp"
#elif defined __sgi
// SGI MIPSpro C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp"
#elif defined __DECCXX
// Compaq Tru64 Unix cxx
# define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp"
#elif defined __ghs
// Greenhills C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp"
#elif defined __BORLANDC__
// Borland
# define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp"
#elif defined __MWERKS__
// Metrowerks CodeWarrior
# define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp"
#elif defined __SUNPRO_CC
// Sun Workshop Compiler C++
# define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp"
#elif defined __HP_aCC
// HP aCC
# define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp"
#elif defined(__MRC__) || defined(__SC__)
// MPW MrCpp or SCpp
# define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp"
#elif defined(__IBMCPP__)
// IBM Visual Age
# define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp"
#elif defined(__PGI)
// Portland Group Inc.
# define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp"
#elif defined _MSC_VER
// Microsoft Visual C++
//
// Must remain the last #elif since some other vendors (Metrowerks, for
// example) also #define _MSC_VER
# define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp"
#elif defined (BOOST_ASSERT_CONFIG)
// this must come last - generate an error if we don't
// recognise the compiler:
# error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)"
#endif
third_party/boost/boost_1_36_0/boost/config/select_platform_config.hpp
externo
-90
Ver Arquivo
@@ -1,90 +0,0 @@
// Boost compiler configuration selection header file
// (C) Copyright John Maddock 2001 - 2002.
// (C) Copyright Jens Maurer 2001.
// 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.
// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed.
// Note that we define the headers to include using "header_name" not
// <header_name> in order to prevent macro expansion within the header
// name (for example "linux" is a macro on linux systems).
#if defined(linux) || defined(__linux) || defined(__linux__)
// linux:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
// BSD:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp"
#elif defined(sun) || defined(__sun)
// solaris:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp"
#elif defined(__sgi)
// SGI Irix:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp"
#elif defined(__hpux)
// hp unix:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp"
#elif defined(__CYGWIN__)
// cygwin is not win32:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
// win32:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"
#elif defined(__BEOS__)
// BeOS
# define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"
#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
// MacOS
# define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"
#elif defined(__IBMCPP__) || defined(_AIX)
// IBM
# define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"
#elif defined(__amigaos__)
// AmigaOS
# define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp"
#elif defined(__QNXNTO__)
// QNX:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp"
#else
# if defined(unix) \
|| defined(__unix) \
|| defined(_XOPEN_SOURCE) \
|| defined(_POSIX_SOURCE)
// generic unix platform:
# ifndef BOOST_HAS_UNISTD_H
# define BOOST_HAS_UNISTD_H
# endif
# include <boost/config/posix_features.hpp>
# endif
# if defined (BOOST_ASSERT_CONFIG)
// this must come last - generate an error if we don't
// recognise the platform:
# error "Unknown platform - please configure and report the results to boost.org"
# endif
#endif
third_party/boost/boost_1_36_0/boost/config/select_stdlib_config.hpp
externo
-68
Ver Arquivo
@@ -1,68 +0,0 @@
// Boost compiler configuration selection header file
// (C) Copyright John Maddock 2001 - 2003.
// (C) Copyright Jens Maurer 2001 - 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)
// See http://www.boost.org for most recent version.
// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed:
// we need to include a std lib header here in order to detect which
// library is in use, use <utility> as it's about the smallest
// of the std lib headers - do not rely on this header being included -
// users can short-circuit this header if they know whose std lib
// they are using.
#include <boost/config/no_tr1/utility.hpp>
#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
// STLPort library; this _must_ come first, otherwise since
// STLport typically sits on top of some other library, we
// can end up detecting that first rather than STLport:
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp"
#elif defined(__LIBCOMO__)
// Comeau STL:
#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp"
#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
// Rogue Wave library:
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp"
#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
// GNU libstdc++ 3
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
#elif defined(__STL_CONFIG_H)
// generic SGI STL
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp"
#elif defined(__MSL_CPP__)
// MSL standard lib:
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp"
#elif defined(__IBMCPP__)
// take the default VACPP std lib
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp"
#elif defined(MSIPL_COMPILE_H)
// Modena C++ standard library
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp"
#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
// Dinkumware Library (this has to appear after any possible replacement libraries):
# define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp"
#elif defined (BOOST_ASSERT_CONFIG)
// this must come last - generate an error if we don't
// recognise the library:
# error "Unknown standard library - please configure and report the results to boost.org"
#endif
third_party/boost/boost_1_36_0/boost/config/stdlib/dinkumware.hpp
externo
-106
Ver Arquivo
@@ -1,106 +0,0 @@
// (C) Copyright John Maddock 2001 - 2003.
// (C) Copyright Jens Maurer 2001.
// (C) Copyright Peter Dimov 2001.
// (C) Copyright David Abrahams 2002.
// (C) Copyright Guillaume Melquiond 2003.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for most recent version.
// Dinkumware standard library config:
#if !defined(_YVALS) && !defined(_CPPLIB_VER)
#include <boost/config/no_tr1/utility.hpp>
#if !defined(_YVALS) && !defined(_CPPLIB_VER)
#error This is not the Dinkumware lib!
#endif
#endif
#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
// full dinkumware 3.06 and above
// fully conforming provided the compiler supports it:
# if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700)) // can be defined in yvals.h
# define BOOST_NO_STDC_NAMESPACE
# endif
# if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC)
# define BOOST_NO_STD_ALLOCATOR
# endif
# define BOOST_HAS_PARTIAL_STD_ALLOCATOR
# if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
// if this lib version is set up for vc6 then there is no std::use_facet:
# define BOOST_NO_STD_USE_FACET
# define BOOST_HAS_TWO_ARG_USE_FACET
// C lib functions aren't in namespace std either:
# define BOOST_NO_STDC_NAMESPACE
// and nor is <exception>
# define BOOST_NO_EXCEPTION_STD_NAMESPACE
# endif
// There's no numeric_limits<long long> support unless _LONGLONG is defined:
# if !defined(_LONGLONG) && (_CPPLIB_VER <= 310)
# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
# endif
// 3.06 appears to have (non-sgi versions of) <hash_set> & <hash_map>,
// and no <slist> at all
#else
# define BOOST_MSVC_STD_ITERATOR 1
# define BOOST_NO_STD_ITERATOR
# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
# define BOOST_NO_STD_ALLOCATOR
# define BOOST_NO_STDC_NAMESPACE
# define BOOST_NO_STD_USE_FACET
# define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
# define BOOST_HAS_MACRO_USE_FACET
# ifndef _CPPLIB_VER
// Updated Dinkum library defines this, and provides
// its own min and max definitions.
# define BOOST_NO_STD_MIN_MAX
# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
# endif
#endif
//
// std extension namespace is stdext for vc7.1 and later,
// the same applies to other compilers that sit on top
// of vc7.1 (Intel and Comeau):
//
#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__)
# define BOOST_STD_EXTENSION_NAMESPACE stdext
#endif
#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306)
// if we're using a dinkum lib that's
// been configured for VC6/7 then there is
// no iterator traits (true even for icl)
# define BOOST_NO_STD_ITERATOR_TRAITS
#endif
#if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310)
// Intel C++ chokes over any non-trivial use of <locale>
// this may be an overly restrictive define, but regex fails without it:
# define BOOST_NO_STD_LOCALE
#endif
#ifdef _CPPLIB_VER
# define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
#else
# define BOOST_DINKUMWARE_STDLIB 1
#endif
#ifdef _CPPLIB_VER
# define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER)
#else
# define BOOST_STDLIB "Dinkumware standard library version 1.x"
#endif
third_party/boost/boost_1_36_0/boost/config/suffix.hpp
externo
-577
Ver Arquivo
@@ -1,577 +0,0 @@
// Boost config.hpp configuration header file ------------------------------//
// (C) Copyright John Maddock 2001 - 2003.
// (C) Copyright Darin Adler 2001.
// (C) Copyright Peter Dimov 2001.
// (C) Copyright Bill Kempf 2002.
// (C) Copyright Jens Maurer 2002.
// (C) Copyright David Abrahams 2002 - 2003.
// (C) Copyright Gennaro Prota 2003.
// (C) Copyright Eric Friedman 2003.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for most recent version.
// Boost config.hpp policy and rationale documentation has been moved to
// http://www.boost.org/libs/config
//
// This file is intended to be stable, and relatively unchanging.
// It should contain boilerplate code only - no compiler specific
// code unless it is unavoidable - no changes unless unavoidable.
#ifndef BOOST_CONFIG_SUFFIX_HPP
#define BOOST_CONFIG_SUFFIX_HPP
//
// look for long long by looking for the appropriate macros in <limits.h>.
// Note that we use limits.h rather than climits for maximal portability,
// remember that since these just declare a bunch of macros, there should be
// no namespace issues from this.
//
#if !defined(BOOST_HAS_LONG_LONG) \
&& !defined(BOOST_MSVC) && !defined(__BORLANDC__)
# include <limits.h>
# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
# define BOOST_HAS_LONG_LONG
# endif
#endif
// GCC 3.x will clean up all of those nasty macro definitions that
// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
// it under GCC 3.x.
#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS)
# undef BOOST_NO_CTYPE_FUNCTIONS
#endif
//
// Assume any extensions are in namespace std:: unless stated otherwise:
//
# ifndef BOOST_STD_EXTENSION_NAMESPACE
# define BOOST_STD_EXTENSION_NAMESPACE std
# endif
//
// If cv-qualified specializations are not allowed, then neither are cv-void ones:
//
# if defined(BOOST_NO_CV_SPECIALIZATIONS) \
&& !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
# define BOOST_NO_CV_VOID_SPECIALIZATIONS
# endif
//
// If there is no numeric_limits template, then it can't have any compile time
// constants either!
//
# if defined(BOOST_NO_LIMITS) \
&& !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
# endif
//
// if there is no long long then there is no specialisation
// for numeric_limits<long long> either:
//
#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
#endif
//
// if there is no __int64 then there is no specialisation
// for numeric_limits<__int64> either:
//
#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)
# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#endif
//
// if member templates are supported then so is the
// VC6 subset of member templates:
//
# if !defined(BOOST_NO_MEMBER_TEMPLATES) \
&& !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
# define BOOST_MSVC6_MEMBER_TEMPLATES
# endif
//
// Without partial specialization, can't test for partial specialisation bugs:
//
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
# endif
//
// Without partial specialization, we can't have array-type partial specialisations:
//
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
# define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
# endif
//
// Without partial specialization, std::iterator_traits can't work:
//
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& !defined(BOOST_NO_STD_ITERATOR_TRAITS)
# define BOOST_NO_STD_ITERATOR_TRAITS
# endif
//
// Without partial specialization, partial
// specialization with default args won't work either:
//
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
# define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
# endif
//
// Without member template support, we can't have template constructors
// in the standard library either:
//
# if defined(BOOST_NO_MEMBER_TEMPLATES) \
&& !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
&& !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
# endif
//
// Without member template support, we can't have a conforming
// std::allocator template either:
//
# if defined(BOOST_NO_MEMBER_TEMPLATES) \
&& !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
&& !defined(BOOST_NO_STD_ALLOCATOR)
# define BOOST_NO_STD_ALLOCATOR
# endif
//
// without ADL support then using declarations will break ADL as well:
//
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#endif
//
// If we have a standard allocator, then we have a partial one as well:
//
#if !defined(BOOST_NO_STD_ALLOCATOR)
# define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#endif
//
// We can't have a working std::use_facet if there is no std::locale:
//
# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET)
# define BOOST_NO_STD_USE_FACET
# endif
//
// We can't have a std::messages facet if there is no std::locale:
//
# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES)
# define BOOST_NO_STD_MESSAGES
# endif
//
// We can't have a working std::wstreambuf if there is no std::locale:
//
# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
# define BOOST_NO_STD_WSTREAMBUF
# endif
//
// We can't have a <cwctype> if there is no <cwchar>:
//
# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE)
# define BOOST_NO_CWCTYPE
# endif
//
// We can't have a swprintf if there is no <cwchar>:
//
# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
# define BOOST_NO_SWPRINTF
# endif
//
// If Win32 support is turned off, then we must turn off
// threading support also, unless there is some other
// thread API enabled:
//
#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \
&& !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS)
# define BOOST_DISABLE_THREADS
#endif
//
// Turn on threading support if the compiler thinks that it's in
// multithreaded mode. We put this here because there are only a
// limited number of macros that identify this (if there's any missing
// from here then add to the appropriate compiler section):
//
#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
|| defined(_PTHREADS)) && !defined(BOOST_HAS_THREADS)
# define BOOST_HAS_THREADS
#endif
//
// Turn threading support off if BOOST_DISABLE_THREADS is defined:
//
#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS)
# undef BOOST_HAS_THREADS
#endif
//
// Turn threading support off if we don't recognise the threading API:
//
#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\
&& !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\
&& !defined(BOOST_HAS_MPTASKS)
# undef BOOST_HAS_THREADS
#endif
//
// Turn threading detail macros off if we don't (want to) use threading
//
#ifndef BOOST_HAS_THREADS
# undef BOOST_HAS_PTHREADS
# undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
# undef BOOST_HAS_PTHREAD_YIELD
# undef BOOST_HAS_PTHREAD_DELAY_NP
# undef BOOST_HAS_WINTHREADS
# undef BOOST_HAS_BETHREADS
# undef BOOST_HAS_MPTASKS
#endif
//
// If the compiler claims to be C99 conformant, then it had better
// have a <stdint.h>:
//
# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
# define BOOST_HAS_STDINT_H
# ifndef BOOST_HAS_LOG1P
# define BOOST_HAS_LOG1P
# endif
# ifndef BOOST_HAS_EXPM1
# define BOOST_HAS_EXPM1
# endif
# endif
//
// Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
// Note that this is for backwards compatibility only.
//
# ifndef BOOST_HAS_SLIST
# define BOOST_NO_SLIST
# endif
# ifndef BOOST_HAS_HASH
# define BOOST_NO_HASH
# endif
//
// Set BOOST_SLIST_HEADER if not set already:
//
#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER)
# define BOOST_SLIST_HEADER <slist>
#endif
//
// Set BOOST_HASH_SET_HEADER if not set already:
//
#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER)
# define BOOST_HASH_SET_HEADER <hash_set>
#endif
//
// Set BOOST_HASH_MAP_HEADER if not set already:
//
#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER)
# define BOOST_HASH_MAP_HEADER <hash_map>
#endif
// BOOST_HAS_ABI_HEADERS
// This macro gets set if we have headers that fix the ABI,
// and prevent ODR violations when linking to external libraries:
#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS)
# define BOOST_HAS_ABI_HEADERS
#endif
#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS)
# undef BOOST_HAS_ABI_HEADERS
#endif
// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------//
// Because std::size_t usage is so common, even in boost headers which do not
// otherwise use the C library, the <cstddef> workaround is included here so
// that ugly workaround code need not appear in many other boost headers.
// NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
// must still be #included in the usual places so that <cstddef> inclusion
// works as expected with standard conforming compilers. The resulting
// double inclusion of <cstddef> is harmless.
# ifdef BOOST_NO_STDC_NAMESPACE
# include <cstddef>
namespace std { using ::ptrdiff_t; using ::size_t; }
# endif
// Workaround for the unfortunate min/max macros defined by some platform headers
#define BOOST_PREVENT_MACRO_SUBSTITUTION
#ifndef BOOST_USING_STD_MIN
# define BOOST_USING_STD_MIN() using std::min
#endif
#ifndef BOOST_USING_STD_MAX
# define BOOST_USING_STD_MAX() using std::max
#endif
// BOOST_NO_STD_MIN_MAX workaround -----------------------------------------//
# ifdef BOOST_NO_STD_MIN_MAX
namespace std {
template <class _Tp>
inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
return __b < __a ? __b : __a;
}
template <class _Tp>
inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
return __a < __b ? __b : __a;
}
}
# endif
// BOOST_STATIC_CONSTANT workaround --------------------------------------- //
// On compilers which don't allow in-class initialization of static integral
// constant members, we must use enums as a workaround if we want the constants
// to be available at compile-time. This macro gives us a convenient way to
// declare such constants.
# ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
# else
# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
# endif
// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
// When the standard library does not have a conforming std::use_facet there
// are various workarounds available, but they differ from library to library.
// The same problem occurs with has_facet.
// These macros provide a consistent way to access a locale's facets.
// Usage:
// replace
// std::use_facet<Type>(loc);
// with
// BOOST_USE_FACET(Type, loc);
// Note do not add a std:: prefix to the front of BOOST_USE_FACET!
// Use for BOOST_HAS_FACET is analagous.
#if defined(BOOST_NO_STD_USE_FACET)
# ifdef BOOST_HAS_TWO_ARG_USE_FACET
# define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
# define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0))
# elif defined(BOOST_HAS_MACRO_USE_FACET)
# define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
# define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
# elif defined(BOOST_HAS_STLP_USE_FACET)
# define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc))
# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
# endif
#else
# define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
#endif
// BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
// Member templates are supported by some compilers even though they can't use
// the A::template member<U> syntax, as a workaround replace:
//
// typedef typename A::template rebind<U> binder;
//
// with:
//
// typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder;
#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
# define BOOST_NESTED_TEMPLATE template
#else
# define BOOST_NESTED_TEMPLATE
#endif
// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION
// is defined, in which case it evaluates to return x; Use when you have a return
// statement that can never be reached.
#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
# define BOOST_UNREACHABLE_RETURN(x) return x;
#else
# define BOOST_UNREACHABLE_RETURN(x)
#endif
// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
//
// Some compilers don't support the use of `typename' for dependent
// types in deduced contexts, e.g.
//
// template <class T> void f(T, typename T::type);
// ^^^^^^^^
// Replace these declarations with:
//
// template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type);
#ifndef BOOST_NO_DEDUCED_TYPENAME
# define BOOST_DEDUCED_TYPENAME typename
#else
# define BOOST_DEDUCED_TYPENAME
#endif
// long long workaround ------------------------------------------//
// On gcc (and maybe other compilers?) long long is alway supported
// but it's use may generate either warnings (with -ansi), or errors
// (with -pedantic -ansi) unless it's use is prefixed by __extension__
//
#if defined(BOOST_HAS_LONG_LONG)
namespace boost{
# ifdef __GNUC__
__extension__ typedef long long long_long_type;
__extension__ typedef unsigned long long ulong_long_type;
# else
typedef long long long_long_type;
typedef unsigned long long ulong_long_type;
# endif
}
#endif
// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
//
// Some compilers have problems with function templates whose
// template parameters don't appear in the function parameter
// list (basically they just link one instantiation of the
// template in the final executable). These macros provide a
// uniform way to cope with the problem with no effects on the
// calling syntax.
// Example:
//
// #include <iostream>
// #include <ostream>
// #include <typeinfo>
//
// template <int n>
// void f() { std::cout << n << ' '; }
//
// template <typename T>
// void g() { std::cout << typeid(T).name() << ' '; }
//
// int main() {
// f<1>();
// f<2>();
//
// g<int>();
// g<double>();
// }
//
// With VC++ 6.0 the output is:
//
// 2 2 double double
//
// To fix it, write
//
// template <int n>
// void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... }
//
// template <typename T>
// void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... }
//
#if defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
# include "boost/type.hpp"
# include "boost/non_type.hpp"
# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type<t>* = 0
# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type<t>*
# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type<t, v>* = 0
# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type<t, v>*
# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \
, BOOST_EXPLICIT_TEMPLATE_TYPE(t)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \
, BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
, BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \
, BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
#else
// no workaround needed: expand to nothing
# define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
#endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
// ---------------------------------------------------------------------------//
//
// Helper macro BOOST_STRINGIZE:
// Converts the parameter X to a string after macro replacement
// on X has been performed.
//
#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#define BOOST_DO_STRINGIZE(X) #X
//
// Helper macro BOOST_JOIN:
// The following piece of macro magic joins the two
// arguments together, even when one of the arguments is
// itself a macro (see 16.3.1 in C++ standard). The key
// is that macro expansion of macro arguments does not
// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN.
//
#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
#define BOOST_DO_JOIN2( X, Y ) X##Y
//
// Set some default values for compiler/library/platform names.
// These are for debugging config setup only:
//
# ifndef BOOST_COMPILER
# define BOOST_COMPILER "Unknown ISO C++ Compiler"
# endif
# ifndef BOOST_STDLIB
# define BOOST_STDLIB "Unknown ISO standard library"
# endif
# ifndef BOOST_PLATFORM
# if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
|| defined(_POSIX_SOURCE)
# define BOOST_PLATFORM "Generic Unix"
# else
# define BOOST_PLATFORM "Unknown"
# endif
# endif
#endif
third_party/boost/boost_1_36_0/boost/config/user.hpp
externo
-124
Ver Arquivo
@@ -1,124 +0,0 @@
// boost/config/user.hpp ---------------------------------------------------//
// (C) Copyright John Maddock 2001.
// 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)
// Do not check in modified versions of this file,
// This file may be customized by the end user, but not by boost.
//
// Use this file to define a site and compiler specific
// configuration policy:
//
// define this to locate a compiler config file:
// #define BOOST_COMPILER_CONFIG <myheader>
// define this to locate a stdlib config file:
// #define BOOST_STDLIB_CONFIG <myheader>
// define this to locate a platform config file:
// #define BOOST_PLATFORM_CONFIG <myheader>
// define this to disable compiler config,
// use if your compiler config has nothing to set:
// #define BOOST_NO_COMPILER_CONFIG
// define this to disable stdlib config,
// use if your stdlib config has nothing to set:
// #define BOOST_NO_STDLIB_CONFIG
// define this to disable platform config,
// use if your platform config has nothing to set:
// #define BOOST_NO_PLATFORM_CONFIG
// define this to disable all config options,
// excluding the user config. Use if your
// setup is fully ISO compliant, and has no
// useful extensions, or for autoconf generated
// setups:
// #define BOOST_NO_CONFIG
// define this to make the config "optimistic"
// about unknown compiler versions. Normally
// unknown compiler versions are assumed to have
// all the defects of the last known version, however
// setting this flag, causes the config to assume
// that unknown compiler versions are fully conformant
// with the standard:
// #define BOOST_STRICT_CONFIG
// define this to cause the config to halt compilation
// with an #error if it encounters anything unknown --
// either an unknown compiler version or an unknown
// compiler/platform/library:
// #define BOOST_ASSERT_CONFIG
// define if you want to disable threading support, even
// when available:
// #define BOOST_DISABLE_THREADS
// define when you want to disable Win32 specific features
// even when available:
// #define BOOST_DISABLE_WIN32
// BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any
// prefix/suffix headers that normally control things like struct
// packing and alignment.
// #define BOOST_DISABLE_ABI_HEADERS
// BOOST_ABI_PREFIX: A prefix header to include in place of whatever
// boost.config would normally select, any replacement should set up
// struct packing and alignment options as required.
// #define BOOST_ABI_PREFIX my-header-name
// BOOST_ABI_SUFFIX: A suffix header to include in place of whatever
// boost.config would normally select, any replacement should undo
// the effects of the prefix header.
// #define BOOST_ABI_SUFFIX my-header-name
// BOOST_ALL_DYN_LINK: Forces all libraries that have separate source,
// to be linked as dll's rather than static libraries on Microsoft Windows
// (this macro is used to turn on __declspec(dllimport) modifiers, so that
// the compiler knows which symbols to look for in a dll rather than in a
// static library). Note that there may be some libraries that can only
// be statically linked (Boost.Test for example) and others which may only
// be dynamically linked (Boost.Threads for example), in these cases this
// macro has no effect.
// #define BOOST_ALL_DYN_LINK
// BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll
// rather than a static library on Microsoft Windows: replace the WHATEVER
// part of the macro name with the name of the library that you want to
// dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or
// BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport)
// modifiers, so that the compiler knows which symbols to look for in a dll
// rather than in a static library).
// Note that there may be some libraries that can only be statically linked
// (Boost.Test for example) and others which may only be dynamically linked
// (Boost.Threads for example), in these cases this macro is unsupported.
// #define BOOST_WHATEVER_DYN_LINK
// BOOST_ALL_NO_LIB: Tells the config system not to automatically select
// which libraries to link against.
// Normally if a compiler supports #pragma lib, then the correct library
// build variant will be automatically selected and linked against,
// simply by the act of including one of that library's headers.
// This macro turns that feature off.
// #define BOOST_ALL_NO_LIB
// BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically
// select which library to link against for library "whatever",
// replace WHATEVER in the macro name with the name of the library;
// for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB.
// Normally if a compiler supports #pragma lib, then the correct library
// build variant will be automatically selected and linked against, simply
// by the act of including one of that library's headers. This macro turns
// that feature off.
// #define BOOST_WHATEVER_NO_LIB
third_party/boost/boost_1_36_0/boost/detail/workaround.hpp
externo
-202
Ver Arquivo
@@ -1,202 +0,0 @@
// Copyright David Abrahams 2002.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef WORKAROUND_DWA2002126_HPP
# define WORKAROUND_DWA2002126_HPP
// Compiler/library version workaround macro
//
// Usage:
//
// #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
// // workaround for eVC4 and VC6
// ... // workaround code here
// #endif
//
// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
// first argument must be undefined or expand to a numeric
// value. The above expands to:
//
// (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
//
// When used for workarounds that apply to the latest known version
// and all earlier versions of a compiler, the following convention
// should be observed:
//
// #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
//
// The version number in this case corresponds to the last version in
// which the workaround was known to have been required. When
// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
// the workaround for any version of the compiler. When
// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
// error will be issued if the compiler version exceeds the argument
// to BOOST_TESTED_AT(). This can be used to locate workarounds which
// may be obsoleted by newer versions.
# ifndef BOOST_STRICT_CONFIG
#include <boost/config.hpp>
#ifndef __BORLANDC__
#define __BORLANDC___WORKAROUND_GUARD 1
#else
#define __BORLANDC___WORKAROUND_GUARD 0
#endif
#ifndef __MSC_VER
#define __MSC_VER_WORKAROUND_GUARD 1
#else
#define __MSC_VER_WORKAROUND_GUARD 0
#endif
#ifndef _MSC_FULL_VER
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#else
#define _MSC_FULL_VER_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_MSVC
#define BOOST_MSVC_WORKAROUND_GUARD 1
#else
#define BOOST_MSVC_WORKAROUND_GUARD 0
#endif
#ifndef __GNUC__
#define __GNUC___WORKAROUND_GUARD 1
#else
#define __GNUC___WORKAROUND_GUARD 0
#endif
#ifndef __GNUC_MINOR__
#define __GNUC_MINOR___WORKAROUND_GUARD 1
#else
#define __GNUC_MINOR___WORKAROUND_GUARD 0
#endif
#ifndef __GNUC_PATCHLEVEL__
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
#else
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
#endif
#ifndef __IBMCPP__
#define __IBMCPP___WORKAROUND_GUARD 1
#else
#define __IBMCPP___WORKAROUND_GUARD 0
#endif
#ifndef __SUNPRO_CC
#define __SUNPRO_CC_WORKAROUND_GUARD 1
#else
#define __SUNPRO_CC_WORKAROUND_GUARD 0
#endif
#ifndef __DECCXX_VER
#define __DECCXX_VER_WORKAROUND_GUARD 1
#else
#define __DECCXX_VER_WORKAROUND_GUARD 0
#endif
#ifndef __MWERKS__
#define __MWERKS___WORKAROUND_GUARD 1
#else
#define __MWERKS___WORKAROUND_GUARD 0
#endif
#ifndef __EDG_VERSION__
#define __EDG_VERSION___WORKAROUND_GUARD 1
#else
#define __EDG_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef __HP_aCC
#define __HP_aCC_WORKAROUND_GUARD 1
#else
#define __HP_aCC_WORKAROUND_GUARD 0
#endif
#ifndef _CRAYC
#define _CRAYC_WORKAROUND_GUARD 1
#else
#define _CRAYC_WORKAROUND_GUARD 0
#endif
#ifndef __DMC__
#define __DMC___WORKAROUND_GUARD 1
#else
#define __DMC___WORKAROUND_GUARD 0
#endif
#ifndef MPW_CPLUS
#define MPW_CPLUS_WORKAROUND_GUARD 1
#else
#define MPW_CPLUS_WORKAROUND_GUARD 0
#endif
#ifndef _RWSTD_VER
#define _RWSTD_VER_WORKAROUND_GUARD 1
#else
#define _RWSTD_VER_WORKAROUND_GUARD 0
#endif
#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#else
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
#endif
#ifndef __SGI_STL_PORT
#define __SGI_STL_PORT_WORKAROUND_GUARD 1
#else
#define __SGI_STL_PORT_WORKAROUND_GUARD 0
#endif
#ifndef _STLPORT_VERSION
#define _STLPORT_VERSION_WORKAROUND_GUARD 1
#else
#define _STLPORT_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL_CXX_VERSION
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL_WIN
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_DINKUMWARE_STDLIB
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
#else
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL
#define BOOST_INTEL_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WORKAROUND_GUARD 0
#endif
// Always define to zero, if it's used it'll be defined my MPL:
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
# define BOOST_WORKAROUND(symbol, test) \
((symbol ## _WORKAROUND_GUARD + 0 == 0) && \
(symbol != 0) && (1 % (( (symbol test) ) + 1)))
// ^ ^ ^ ^
// The extra level of parenthesis nesting above, along with the
// BOOST_OPEN_PAREN indirection below, is required to satisfy the
// broken preprocessor in MWCW 8.3 and earlier.
//
// The basic mechanism works as follows:
// (symbol test) + 1 => if (symbol test) then 2 else 1
// 1 % ((symbol test) + 1) => if (symbol test) then 1 else 0
//
// The complication with % is for cooperation with BOOST_TESTED_AT().
// When "test" is BOOST_TESTED_AT(x) and
// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
//
// symbol test => if (symbol <= x) then 1 else -1
// (symbol test) + 1 => if (symbol <= x) then 2 else 0
// 1 % ((symbol test) + 1) => if (symbol <= x) then 1 else divide-by-zero
//
# ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
# define BOOST_OPEN_PAREN (
# define BOOST_TESTED_AT(value) > value) ?(-1): BOOST_OPEN_PAREN 1
# else
# define BOOST_TESTED_AT(value) != ((value)-(value))
# endif
# else
# define BOOST_WORKAROUND(symbol, test) 0
# endif
#endif // WORKAROUND_DWA2002126_HPP
third_party/boost/boost_1_36_0/boost/fusion/adapted/std_pair.hpp
externo
-70
Ver Arquivo
@@ -1,70 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_PAIR_24122005_1744)
#define BOOST_FUSION_STD_PAIR_24122005_1744
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/adapted/struct.hpp>
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace traits
{
template <typename T1, typename T2>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
struct tag_of<std::pair<T1, T2>, void >
#else
struct tag_of<std::pair<T1, T2> >
#endif
{
typedef struct_tag type;
};
}
namespace extension
{
template <typename Struct, int N>
struct struct_member;
template <typename Struct>
struct struct_size;
template <typename T1, typename T2>
struct struct_member<std::pair<T1, T2>, 0>
{
typedef T1 type;
static type& call(std::pair<T1, T2>& pair)
{
return pair.first;
}
};
template <typename T1, typename T2>
struct struct_member<std::pair<T1, T2>, 1>
{
typedef T2 type;
static type& call(std::pair<T1, T2>& pair)
{
return pair.second;
}
};
template <typename T1, typename T2>
struct struct_size<std::pair<T1, T2> > : mpl::int_<2>
{
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct.hpp
externo
-28
Ver Arquivo
@@ -1,28 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STRUCT_24122005_1744)
#define BOOST_FUSION_STRUCT_24122005_1744
#include <boost/fusion/adapted/struct/extension.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_key_impl.hpp>
#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
#include <boost/fusion/adapted/struct/detail/has_key_impl.hpp>
#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_key_impl.hpp>
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/adapt_assoc_struct.hpp
externo
-94
Ver Arquivo
@@ -1,94 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2007 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_ADAPT_ASSOC_STRUCT_20070508_2207)
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_20070508_2207
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/adapted/struct/extension.hpp>
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
#include <boost/fusion/adapted/struct/detail/has_key_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_key_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_key_impl.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion { namespace extension {
template<typename Struct, typename Key>
struct struct_assoc_member;
}}}
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT(name, bseq) \
BOOST_FUSION_ADAPT_ASSOC_STRUCT_I( \
name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_STRUCT_X bseq, 0)) \
/***/
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_X(x, y, z) ((x, y, z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_Y
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_Y(x, y, z) ((x, y, z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_X
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_X0
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_Y0
// BOOST_FUSION_ADAPT_ASSOC_STRUCT_I generates the overarching structure and uses
// SEQ_FOR_EACH_I to generate the "linear" substructures.
// Thanks to Paul Mensonides for the PP macro help
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_I(name, seq) \
namespace boost { namespace fusion { namespace traits \
{ \
template <> \
struct tag_of<name> \
{ \
typedef struct_tag type; \
}; \
}}} \
namespace boost { namespace fusion { namespace extension \
{ \
template <> \
struct struct_size<name> : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {}; \
BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_ASSOC_STRUCT_C, name, seq) \
}}} \
/***/
#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C(r, name, i, xy) \
template <> \
struct struct_member<name, i> \
{ \
typedef BOOST_PP_TUPLE_ELEM(3, 0, xy) type; \
static type& call(name& struct_) \
{ \
return struct_.BOOST_PP_TUPLE_ELEM(3, 1, xy); \
}; \
}; \
template<> \
struct struct_assoc_member<name, BOOST_PP_TUPLE_ELEM(3, 2, xy)> \
{ \
typedef BOOST_PP_TUPLE_ELEM(3, 0, xy) type; \
static type& call(name& struct_) \
{ \
return struct_.BOOST_PP_TUPLE_ELEM(3, 1, xy); \
}; \
};
/***/
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/adapt_struct.hpp
externo
-75
Ver Arquivo
@@ -1,75 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_ADAPT_STRUCT_APRIL_2_2007_1158AM)
#define BOOST_FUSION_ADAPT_STRUCT_APRIL_2_2007_1158AM
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/adapted/struct/extension.hpp>
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
#define BOOST_FUSION_ADAPT_STRUCT(name, bseq) \
BOOST_FUSION_ADAPT_STRUCT_I( \
name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_X bseq, 0)) \
/***/
#define BOOST_FUSION_ADAPT_STRUCT_X(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_Y
#define BOOST_FUSION_ADAPT_STRUCT_Y(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_X
#define BOOST_FUSION_ADAPT_STRUCT_X0
#define BOOST_FUSION_ADAPT_STRUCT_Y0
// BOOST_FUSION_ADAPT_STRUCT_I generates the overarching structure and uses
// SEQ_FOR_EACH_I to generate the "linear" substructures.
// Thanks to Paul Mensonides for the PP macro help
#define BOOST_FUSION_ADAPT_STRUCT_I(name, seq) \
namespace boost { namespace fusion { namespace traits \
{ \
template <> \
struct tag_of<name> \
{ \
typedef struct_tag type; \
}; \
}}} \
namespace boost { namespace fusion { namespace extension \
{ \
template <> \
struct struct_size<name> : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {}; \
BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_STRUCT_C, name, seq) \
}}} \
/***/
#define BOOST_FUSION_ADAPT_STRUCT_C(r, name, i, xy) \
template <> \
struct struct_member<name, i> \
{ \
typedef BOOST_PP_TUPLE_ELEM(2, 0, xy) type; \
static type& call(name& struct_) \
{ \
return struct_.BOOST_PP_TUPLE_ELEM(2, 1, xy); \
}; \
}; \
/***/
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/at_impl.hpp
externo
-63
Ver Arquivo
@@ -1,63 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_AT_IMPL_24122005_1807)
#define BOOST_FUSION_AT_IMPL_24122005_1807
#include <boost/fusion/support/detail/access.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/int.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename T>
struct at_impl;
template <typename Struct, int N>
struct struct_member;
template <typename Struct>
struct struct_size;
template <>
struct at_impl<struct_tag>
{
template <typename Sequence, typename N>
struct apply
{
static int const n_value = N::value;
BOOST_MPL_ASSERT_RELATION(
n_value, <=, extension::struct_size<Sequence>::value);
typedef typename
extension::struct_member<Sequence, N::value>
element;
typedef typename
mpl::eval_if<
is_const<Sequence>
, detail::cref_result<element>
, detail::ref_result<element>
>::type
type;
static type
call(Sequence& seq)
{
return extension::
struct_member<Sequence, N::value>::call(seq);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/at_key_impl.hpp
externo
-54
Ver Arquivo
@@ -1,54 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2005-2007 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_AT_KEY_IMPL_20070508_2248)
#define BOOST_FUSION_AT_KEY_IMPL_20070508_2248
#include <boost/fusion/support/detail/access.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename T>
struct at_key_impl;
template <typename Struct, typename Key>
struct struct_assoc_member;
template <>
struct at_key_impl<struct_tag>
{
template <typename Sequence, typename Key>
struct apply
{
typedef typename
extension::struct_assoc_member<Sequence, Key>
element;
typedef typename
mpl::eval_if<
is_const<Sequence>
, detail::cref_result<element>
, detail::ref_result<element>
>::type
type;
static type
call(Sequence& seq)
{
return extension::
struct_assoc_member<Sequence, Key>::call(seq);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/begin_impl.hpp
externo
-40
Ver Arquivo
@@ -1,40 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_BEGIN_IMPL_24122005_1752)
#define BOOST_FUSION_BEGIN_IMPL_24122005_1752
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename T>
struct begin_impl;
template <>
struct begin_impl<struct_tag>
{
template <typename Sequence>
struct apply
{
typedef struct_iterator<Sequence, 0> type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/category_of_impl.hpp
externo
-35
Ver Arquivo
@@ -1,35 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_CATEGORY_OF_IMPL_24122005_1731)
#define BOOST_FUSION_CATEGORY_OF_IMPL_24122005_1731
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
struct random_access_traversal_tag;
namespace extension
{
template<typename T>
struct category_of_impl;
template<>
struct category_of_impl<struct_tag>
{
template<typename T>
struct apply
{
typedef random_access_traversal_tag type;
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/end_impl.hpp
externo
-48
Ver Arquivo
@@ -1,48 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_END_IMPL_24122005_1755)
#define BOOST_FUSION_END_IMPL_24122005_1755
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template <typename Tag>
struct end_impl;
template <typename Struct>
struct struct_size;
template <>
struct end_impl<struct_tag>
{
template <typename Sequence>
struct apply
{
typedef
struct_iterator<
Sequence
, struct_size<Sequence>::value
>
type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/has_key_impl.hpp
externo
-40
Ver Arquivo
@@ -1,40 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2005-2007 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_HAS_KEY_IMPL_20070508_2231)
#define BOOST_FUSION_HAS_KEY_IMPL_20070508_2231
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/not.hpp>
namespace boost { namespace fusion {
struct struct_tag;
namespace extension
{
struct no_such_member;
template<typename T>
struct has_key_impl;
template<typename Struct, typename Key>
struct struct_assoc_member;
template<>
struct has_key_impl<struct_tag>
{
template<typename Sequence, typename Key>
struct apply
: mpl::not_<is_same<no_such_member, typename struct_assoc_member<Sequence, Key>::type> >
{
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp
externo
-31
Ver Arquivo
@@ -1,31 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_IS_SEQUENCE_IMPL_27122005_1651)
#define BOOST_FUSION_IS_SEQUENCE_IMPL_27122005_1651
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename Tag>
struct is_sequence_impl;
template<>
struct is_sequence_impl<struct_tag>
{
template<typename Sequence>
struct apply : mpl::true_ {};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/is_view_impl.hpp
externo
-32
Ver Arquivo
@@ -1,32 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_IS_VIEW_IMPL_27042006_2219)
#define BOOST_FUSION_IS_VIEW_IMPL_27042006_2219
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename Tag>
struct is_view_impl;
template<>
struct is_view_impl<struct_tag>
{
template<typename T>
struct apply : mpl::false_
{};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/size_impl.hpp
externo
-37
Ver Arquivo
@@ -1,37 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_SIZE_IMPL_24122005_1759)
#define BOOST_FUSION_SIZE_IMPL_24122005_1759
#include <boost/mpl/int.hpp>
namespace boost { namespace fusion
{
namespace extension
{
template <typename Struct>
struct struct_size;
}
struct struct_tag;
namespace extension
{
template<typename T>
struct size_impl;
template <>
struct size_impl<struct_tag>
{
template <typename Sequence>
struct apply : extension::struct_size<Sequence> {};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/value_at_impl.hpp
externo
-47
Ver Arquivo
@@ -1,47 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_VALUE_AT_IMPL_24122005_1917)
#define BOOST_FUSION_VALUE_AT_IMPL_24122005_1917
#include <boost/mpl/if.hpp>
#include <boost/static_assert.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename T>
struct value_at_impl;
template <typename Struct, int N>
struct struct_member;
template <typename Struct>
struct struct_size;
template <>
struct value_at_impl<struct_tag>
{
template <typename Sequence, typename N>
struct apply
{
static int const n_value = N::value;
BOOST_MPL_ASSERT_RELATION(
n_value, <=, extension::struct_size<Sequence>::value);
typedef typename
extension::struct_member<Sequence, N::value>::type
type;
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/detail/value_at_key_impl.hpp
externo
-39
Ver Arquivo
@@ -1,39 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2005-2007 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_VALUE_AT_KEY_IMPL_20070508_2300)
#define BOOST_FUSION_VALUE_AT_KEY_IMPL_20070508_2300
#include <boost/mpl/if.hpp>
namespace boost { namespace fusion
{
struct struct_tag;
namespace extension
{
template<typename T>
struct value_at_key_impl;
template <typename Struct, typename Key>
struct struct_assoc_member;
template <>
struct value_at_key_impl<struct_tag>
{
template <typename Sequence, typename Key>
struct apply
{
typedef typename
extension::struct_assoc_member<Sequence, Key>::type
type;
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/extension.hpp
externo
-68
Ver Arquivo
@@ -1,68 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_STRUCT_EXTENSION_APRIL_2_2007_1008AM)
#define FUSION_STRUCT_EXTENSION_APRIL_2_2007_1008AM
#include <boost/type_traits/add_const.hpp>
namespace boost { namespace fusion { namespace extension
{
template <typename Struct, int N>
struct struct_member;
template <typename Struct>
struct struct_size;
template <typename Struct, int N>
struct struct_member<Struct const, N>
{
typedef typename
add_const<typename struct_member<Struct, N>::type>::type
type;
static type&
call(Struct const& struct_)
{
return struct_member<Struct, N>::call(
const_cast<Struct&>(struct_));
}
};
template <typename Struct>
struct struct_size<Struct const>
: struct_size<Struct>
{};
struct no_such_member;
template<typename Struct, typename Key>
struct struct_assoc_member
{
typedef no_such_member type;
};
template<typename Struct, typename Key>
struct struct_assoc_member<Struct const, Key>
{
typedef typename
add_const<typename struct_assoc_member<Struct, Key>::type>::type
type;
static type&
call(Struct const& struct_)
{
return struct_assoc_member<Struct, Key>::call(
const_cast<Struct&>(struct_));
}
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/adapted/struct/struct_iterator.hpp
externo
-103
Ver Arquivo
@@ -1,103 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_STRUCT_ITERATOR_APRIL_2_2007_1008AM)
#define FUSION_STRUCT_ITERATOR_APRIL_2_2007_1008AM
#include <boost/fusion/iterator/iterator_facade.hpp>
#include <boost/fusion/adapted/struct/extension.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion
{
struct random_access_traversal_tag;
template <typename Struct, int N_>
struct struct_iterator
: iterator_facade<struct_iterator<Struct, N_>, random_access_traversal_tag>
{
BOOST_MPL_ASSERT_RELATION(N_, >=, 0);
BOOST_MPL_ASSERT_RELATION(N_, <=, extension::struct_size<Struct>::value);
typedef mpl::int_<N_> index;
typedef Struct struct_type;
struct_iterator(Struct& struct_)
: struct_(struct_) {}
Struct& struct_;
template <typename Iterator>
struct value_of
: extension::struct_member<Struct, N_>
{
};
template <typename Iterator>
struct deref
{
typedef typename
add_reference<
typename extension::struct_member<Struct, N_>::type
>::type
type;
static type
call(Iterator const& iter)
{
return extension::struct_member<Struct, N_>::
call(iter.struct_);
}
};
template <typename Iterator, typename N>
struct advance
{
typedef typename Iterator::index index;
typedef typename Iterator::struct_type struct_type;
typedef struct_iterator<struct_type, index::value + N::value> type;
static type
call(Iterator const& iter)
{
return type(iter.struct_);
}
};
template <typename Iterator>
struct next : advance<Iterator, mpl::int_<1> > {};
template <typename Iterator>
struct prior : advance<Iterator, mpl::int_<-1> > {};
template <typename I1, typename I2>
struct distance : mpl::minus<typename I2::index, typename I1::index>
{
typedef typename
mpl::minus<
typename I2::index, typename I1::index
>::type
type;
static type
call(I1 const&, I2 const&)
{
return type();
}
};
};
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/generation/ignore.hpp
externo
-32
Ver Arquivo
@@ -1,32 +0,0 @@
/*=============================================================================
Copyright (c) 2001 Doug Gregor
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_IGNORE_07192005_0329)
#define FUSION_IGNORE_07192005_0329
namespace boost { namespace fusion
{
// Swallows any assignment (by Doug Gregor)
namespace detail
{
struct swallow_assign
{
template<typename T>
swallow_assign const&
operator=(const T&) const
{
return *this;
}
};
}
// "ignore" allows tuple positions to be ignored when using "tie".
detail::swallow_assign const ignore = detail::swallow_assign();
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/advance_impl.hpp
externo
-42
Ver Arquivo
@@ -1,42 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_ADVANCE_IMPL_09172005_1156)
#define FUSION_ADVANCE_IMPL_09172005_1156
namespace boost { namespace fusion
{
struct vector_iterator_tag;
template <typename Vector, int N>
struct vector_iterator;
namespace extension
{
template <typename Tag>
struct advance_impl;
template <>
struct advance_impl<vector_iterator_tag>
{
template <typename Iterator, typename N>
struct apply
{
typedef typename Iterator::index index;
typedef typename Iterator::vector vector;
typedef vector_iterator<vector, index::value+N::value> type;
static type
call(Iterator const& i)
{
return type(i.vec);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/at_impl.hpp
externo
-49
Ver Arquivo
@@ -1,49 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_AT_IMPL_05042005_0741)
#define FUSION_AT_IMPL_05042005_0741
#include <boost/fusion/support/detail/access.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/int.hpp>
namespace boost { namespace fusion
{
struct vector_tag;
namespace extension
{
template <typename Tag>
struct at_impl;
template <>
struct at_impl<vector_tag>
{
template <typename Sequence, typename N>
struct apply
{
typedef mpl::at<typename Sequence::types, N> element;
typedef typename
mpl::eval_if<
is_const<Sequence>
, detail::cref_result<element>
, detail::ref_result<element>
>::type
type;
static type
call(Sequence& v)
{
return v.at_impl(N());
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/begin_impl.hpp
externo
-39
Ver Arquivo
@@ -1,39 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_BEGIN_IMPL_05042005_1136)
#define FUSION_BEGIN_IMPL_05042005_1136
#include <boost/fusion/container/vector/vector_iterator.hpp>
namespace boost { namespace fusion
{
struct vector_tag;
namespace extension
{
template <typename Tag>
struct begin_impl;
template <>
struct begin_impl<vector_tag>
{
template <typename Sequence>
struct apply
{
typedef vector_iterator<Sequence, 0> type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/deref_impl.hpp
externo
-53
Ver Arquivo
@@ -1,53 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_DEREF_IMPL_05042005_1037)
#define FUSION_DEREF_IMPL_05042005_1037
#include <boost/mpl/at.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/type_traits/is_const.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
namespace extension
{
template <typename Tag>
struct deref_impl;
template <>
struct deref_impl<vector_iterator_tag>
{
template <typename Iterator>
struct apply
{
typedef typename Iterator::vector vector;
typedef typename Iterator::index index;
typedef typename mpl::at<
typename vector::types, index>
element;
typedef typename
mpl::eval_if<
is_const<vector>
, fusion::detail::cref_result<element>
, fusion::detail::ref_result<element>
>::type
type;
static type
call(Iterator const& i)
{
return i.vec.at_impl(index());
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/distance_impl.hpp
externo
-41
Ver Arquivo
@@ -1,41 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_DISTANCE_IMPL_09172005_0751)
#define FUSION_DISTANCE_IMPL_09172005_0751
#include <boost/mpl/minus.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
namespace extension
{
template <typename Tag>
struct distance_impl;
template <>
struct distance_impl<vector_iterator_tag>
{
template <typename First, typename Last>
struct apply : mpl::minus<typename Last::index, typename First::index>
{
static typename mpl::minus<
typename Last::index, typename First::index>::type
call(First const&, Last const&)
{
typedef typename mpl::minus<
typename Last::index, typename First::index>::type
result;
return result();
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/end_impl.hpp
externo
-40
Ver Arquivo
@@ -1,40 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_END_IMPL_05042005_1142)
#define FUSION_END_IMPL_05042005_1142
#include <boost/fusion/container/vector/vector_iterator.hpp>
namespace boost { namespace fusion
{
struct vector_tag;
namespace extension
{
template <typename Tag>
struct end_impl;
template <>
struct end_impl<vector_tag>
{
template <typename Sequence>
struct apply
{
typedef typename Sequence::size size;
typedef vector_iterator<Sequence, size::value> type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/equal_to_impl.hpp
externo
-39
Ver Arquivo
@@ -1,39 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_EQUAL_TO_IMPL_05052005_1215)
#define FUSION_EQUAL_TO_IMPL_05052005_1215
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/and.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
namespace extension
{
template <typename Tag>
struct equal_to_impl;
template <>
struct equal_to_impl<vector_iterator_tag>
{
template <typename I1, typename I2>
struct apply
: is_same<
typename I1::identity
, typename I2::identity
>
{
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/next_impl.hpp
externo
-43
Ver Arquivo
@@ -1,43 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_NEXT_IMPL_05042005_1058)
#define FUSION_NEXT_IMPL_05042005_1058
#include <boost/fusion/container/vector/vector_iterator.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
template <typename Vector, int N>
struct vector_iterator;
namespace extension
{
template <typename Tag>
struct next_impl;
template <>
struct next_impl<vector_iterator_tag>
{
template <typename Iterator>
struct apply
{
typedef typename Iterator::vector vector;
typedef typename Iterator::index index;
typedef vector_iterator<vector, index::value+1> type;
static type
call(Iterator const& i)
{
return type(i.vec);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/prior_impl.hpp
externo
-43
Ver Arquivo
@@ -1,43 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_PRIOR_IMPL_05042005_1145)
#define FUSION_PRIOR_IMPL_05042005_1145
#include <boost/fusion/container/vector/vector_iterator.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
template <typename Vector, int N>
struct vector_iterator;
namespace extension
{
template <typename Tag>
struct prior_impl;
template <>
struct prior_impl<vector_iterator_tag>
{
template <typename Iterator>
struct apply
{
typedef typename Iterator::vector vector;
typedef typename Iterator::index index;
typedef vector_iterator<vector, index::value-1> type;
static type
call(Iterator const& i)
{
return type(i.vec);
}
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/value_at_impl.hpp
externo
-33
Ver Arquivo
@@ -1,33 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VALUE_AT_IMPL_05052005_0232)
#define FUSION_VALUE_AT_IMPL_05052005_0232
#include <boost/mpl/at.hpp>
namespace boost { namespace fusion
{
struct vector_tag;
namespace extension
{
template <typename Tag>
struct value_at_impl;
template <>
struct value_at_impl<vector_tag>
{
template <typename Sequence, typename N>
struct apply
{
typedef typename mpl::at<typename Sequence::types, N>::type type;
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/value_of_impl.hpp
externo
-37
Ver Arquivo
@@ -1,37 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VALUE_OF_IMPL_05052005_1128)
#define FUSION_VALUE_OF_IMPL_05052005_1128
#include <boost/mpl/at.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
namespace extension
{
template <typename Tag>
struct value_of_impl;
template <>
struct value_of_impl<vector_iterator_tag>
{
template <typename Iterator>
struct apply
{
typedef typename Iterator::vector vector;
typedef typename Iterator::index index;
typedef typename mpl::at<
typename vector::types, index>::type
type;
};
};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/vector_forward_ctor.hpp
externo
-39
Ver Arquivo
@@ -1,39 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_VECTOR_FORWARD_CTOR_07122005_1123)
#define FUSION_VECTOR_FORWARD_CTOR_07122005_1123
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define BOOST_PP_FILENAME_1 \
<boost/fusion/container/vector/detail/vector_forward_ctor.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
#if N == 1
explicit
#endif
vector(BOOST_PP_ENUM_BINARY_PARAMS(
N, typename detail::call_param<T, >::type _))
: vec(BOOST_PP_ENUM_PARAMS(N, _)) {}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/vector_n.hpp
externo
-150
Ver Arquivo
@@ -1,150 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
// No include guard. This file is meant to be included many times
#if !defined(FUSION_MACRO_05042005)
#define FUSION_MACRO_05042005
#define FUSION_MEMBER_DEFAULT_INIT(z, n, _) m##n(T##n())
#define FUSION_MEMBER_INIT(z, n, _) m##n(_##n)
#define FUSION_COPY_INIT(z, n, _) m##n(other.m##n)
#define FUSION_MEMBER_DECL(z, n, _) T##n m##n;
#define FUSION_MEMBER_ASSIGN(z, n, _) \
this->BOOST_PP_CAT(m, n) = vec.BOOST_PP_CAT(m, n);
#define FUSION_DEREF_MEMBER_ASSIGN(z, n, _) \
this->BOOST_PP_CAT(m, n) = *BOOST_PP_CAT(i, n);
#define FUSION_AT_IMPL(z, n, _) \
typename add_reference<T##n>::type \
at_impl(mpl::int_<n>) { return this->m##n; } \
typename add_reference<typename add_const<T##n>::type>::type \
at_impl(mpl::int_<n>) const { return this->m##n; }
#define FUSION_ITER_DECL_VAR(z, n, _) \
typedef typename result_of::next< \
BOOST_PP_CAT(I, BOOST_PP_DEC(n))>::type BOOST_PP_CAT(I, n); \
BOOST_PP_CAT(I, n) BOOST_PP_CAT(i, n) \
= fusion::next(BOOST_PP_CAT(i, BOOST_PP_DEC(n)));
#endif
#define N BOOST_PP_ITERATION()
template <typename Derived, BOOST_PP_ENUM_PARAMS(N, typename T)>
struct BOOST_PP_CAT(vector_data, N) : sequence_base<Derived>
{
BOOST_PP_CAT(vector_data, N)()
: BOOST_PP_ENUM(N, FUSION_MEMBER_DEFAULT_INIT, _) {}
BOOST_PP_CAT(vector_data, N)(
BOOST_PP_ENUM_BINARY_PARAMS(
N, typename detail::call_param<T, >::type _))
: BOOST_PP_ENUM(N, FUSION_MEMBER_INIT, _) {}
BOOST_PP_CAT(vector_data, N)(
BOOST_PP_CAT(vector_data, N) const& other)
: BOOST_PP_ENUM(N, FUSION_COPY_INIT, _) {}
BOOST_PP_CAT(vector_data, N)&
operator=(BOOST_PP_CAT(vector_data, N) const& vec)
{
BOOST_PP_REPEAT(N, FUSION_MEMBER_ASSIGN, _)
return *this;
}
template <typename Sequence>
static BOOST_PP_CAT(vector_data, N)
init_from_sequence(Sequence const& seq)
{
typedef typename result_of::begin<Sequence const>::type I0;
I0 i0 = fusion::begin(seq);
BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _)
return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
}
BOOST_PP_REPEAT(N, FUSION_MEMBER_DECL, _)
};
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct BOOST_PP_CAT(vector, N)
: BOOST_PP_CAT(vector_data, N)<
BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)>
, BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> this_type;
typedef BOOST_PP_CAT(vector_data, N)<this_type, BOOST_PP_ENUM_PARAMS(N, T)> base_type;
typedef mpl::BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> types;
typedef vector_tag fusion_tag;
typedef fusion_sequence_tag tag; // this gets picked up by MPL
typedef mpl::false_ is_view;
typedef random_access_traversal_tag category;
typedef mpl::int_<N> size;
BOOST_PP_CAT(vector, N)() {}
#if (N == 1)
explicit
#endif
BOOST_PP_CAT(vector, N)(
BOOST_PP_ENUM_BINARY_PARAMS(
N, typename detail::call_param<T, >::type _))
: base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
template <BOOST_PP_ENUM_PARAMS(N, typename U)>
BOOST_PP_CAT(vector, N)(
BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
: base_type(BOOST_PP_ENUM_PARAMS(N, vec.m)) {}
template <typename Sequence>
BOOST_PP_CAT(vector, N)(
Sequence const& seq
#if (N == 1)
, typename disable_if<is_convertible<Sequence, T0> >::type* dummy = 0
#endif
)
: base_type(base_type::init_from_sequence(seq)) {}
template <BOOST_PP_ENUM_PARAMS(N, typename U)>
BOOST_PP_CAT(vector, N)&
operator=(BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
{
BOOST_PP_REPEAT(N, FUSION_MEMBER_ASSIGN, _)
return *this;
}
template <typename Sequence>
typename disable_if<is_convertible<Sequence, T0>, this_type&>::type
operator=(Sequence const& seq)
{
typedef typename result_of::begin<Sequence const>::type I0;
I0 i0 = fusion::begin(seq);
BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _)
BOOST_PP_REPEAT(N, FUSION_DEREF_MEMBER_ASSIGN, _)
return *this;
}
BOOST_PP_REPEAT(N, FUSION_AT_IMPL, _)
template<typename I>
typename add_reference<typename mpl::at<types, I>::type>::type
at_impl(I i)
{
return this->at_impl(mpl::int_<I::value>());
}
template<typename I>
typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
at_impl(I i) const
{
return this->at_impl(mpl::int_<I::value>());
}
};
#undef N
third_party/boost/boost_1_36_0/boost/fusion/container/vector/detail/vector_n_chooser.hpp
externo
-99
Ver Arquivo
@@ -1,99 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_VECTOR_N_CHOOSER_07072005_1248)
#define FUSION_VECTOR_N_CHOOSER_07072005_1248
#include <boost/fusion/container/vector/limits.hpp>
// include vector0..N where N is FUSION_MAX_VECTOR_SIZE
#include <boost/fusion/container/vector/vector10.hpp>
#if (FUSION_MAX_VECTOR_SIZE > 10)
#include <boost/fusion/container/vector/vector20.hpp>
#endif
#if (FUSION_MAX_VECTOR_SIZE > 20)
#include <boost/fusion/container/vector/vector30.hpp>
#endif
#if (FUSION_MAX_VECTOR_SIZE > 30)
#include <boost/fusion/container/vector/vector40.hpp>
#endif
#if (FUSION_MAX_VECTOR_SIZE > 40)
#include <boost/fusion/container/vector/vector50.hpp>
#endif
#include <boost/mpl/distance.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
namespace boost { namespace fusion
{
struct void_;
}}
namespace boost { namespace fusion { namespace detail
{
template <int N>
struct get_vector_n;
template <>
struct get_vector_n<0>
{
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename T)>
struct call
{
typedef vector0 type;
};
};
#define BOOST_PP_FILENAME_1 \
<boost/fusion/container/vector/detail/vector_n_chooser.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename T)>
struct vector_n_chooser
{
typedef
mpl::BOOST_PP_CAT(vector, FUSION_MAX_VECTOR_SIZE)
<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>
input;
typedef typename mpl::begin<input>::type begin;
typedef typename mpl::find<input, void_>::type end;
typedef typename mpl::distance<begin, end>::type size;
typedef typename get_vector_n<size::value>::template
call<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>::type
type;
};
}}}
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#else // defined(BOOST_PP_IS_ITERATING)
#define N BOOST_PP_ITERATION()
template <>
struct get_vector_n<N>
{
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename T)>
struct call
{
typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> type;
};
};
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
third_party/boost/boost_1_36_0/boost/fusion/container/vector/limits.hpp
externo
-19
Ver Arquivo
@@ -1,19 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VECTOR_LIMITS_07072005_1246)
#define FUSION_VECTOR_LIMITS_07072005_1246
#if !defined(FUSION_MAX_VECTOR_SIZE)
# define FUSION_MAX_VECTOR_SIZE 10
#else
# if FUSION_MAX_VECTOR_SIZE < 3
# undef FUSION_MAX_VECTOR_SIZE
# define FUSION_MAX_VECTOR_SIZE 10
# endif
#endif
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/vector.hpp
externo
-151
Ver Arquivo
@@ -1,151 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VECTOR_07072005_1244)
#define FUSION_VECTOR_07072005_1244
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/fusion/container/vector/detail/vector_n_chooser.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/detail/workaround.hpp>
namespace boost { namespace fusion
{
struct void_;
struct fusion_sequence_tag;
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename T)>
struct vector
: sequence_base<vector<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)> >
{
private:
typedef typename detail::vector_n_chooser<
BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>::type
vector_n;
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename U)>
friend struct vector;
public:
typedef typename vector_n::types types;
typedef typename vector_n::fusion_tag fusion_tag;
typedef typename vector_n::tag tag;
typedef typename vector_n::size size;
typedef typename vector_n::category category;
typedef typename vector_n::is_view is_view;
vector()
: vec() {}
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename U)>
vector(vector<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, U)> const& rhs)
: vec(rhs.vec) {}
vector(vector const& rhs)
: vec(rhs.vec) {}
template <typename Sequence>
vector(Sequence const& rhs)
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
: vec(ctor_helper(rhs, is_base_of<vector, Sequence>())) {}
#else
: vec(rhs) {}
#endif
// Expand a couple of forwarding constructors for arguments
// of type (T0), (T0, T1), (T0, T1, T2) etc. Example:
//
// vector(
// typename detail::call_param<T0>::type _0
// , typename detail::call_param<T1>::type _1)
// : vec(_0, _1) {}
#include <boost/fusion/container/vector/detail/vector_forward_ctor.hpp>
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename U)>
vector&
operator=(vector<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, U)> const& rhs)
{
vec = rhs.vec;
return *this;
}
template <typename T>
vector&
operator=(T const& rhs)
{
vec = rhs;
return *this;
}
template <int N>
typename add_reference<
typename mpl::at_c<types, N>::type
>::type
at_impl(mpl::int_<N> index)
{
return vec.at_impl(index);
}
template <int N>
typename add_reference<
typename add_const<
typename mpl::at_c<types, N>::type
>::type
>::type
at_impl(mpl::int_<N> index) const
{
return vec.at_impl(index);
}
template <typename I>
typename add_reference<
typename mpl::at<types, I>::type
>::type
at_impl(I index)
{
return vec.at_impl(mpl::int_<I::value>());
}
template<typename I>
typename add_reference<
typename add_const<
typename mpl::at<types, I>::type
>::type
>::type
at_impl(I index) const
{
return vec.at_impl(mpl::int_<I::value>());
}
private:
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
static vector_n const&
ctor_helper(vector const& rhs, mpl::true_)
{
return rhs.vec;
}
template <typename T>
static T const&
ctor_helper(T const& rhs, mpl::false_)
{
return rhs;
}
#endif
vector_n vec;
};
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/vector10.hpp
externo
-66
Ver Arquivo
@@ -1,66 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VECTOR10_05042005_0257)
#define FUSION_VECTOR10_05042005_0257
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/container/vector/detail/at_impl.hpp>
#include <boost/fusion/container/vector/detail/value_at_impl.hpp>
#include <boost/fusion/container/vector/detail/begin_impl.hpp>
#include <boost/fusion/container/vector/detail/end_impl.hpp>
#include <boost/mpl/void.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/vector/vector10.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/preprocessor/dec.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_shifted.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
namespace boost { namespace fusion
{
struct vector_tag;
struct fusion_sequence_tag;
struct random_access_traversal_tag;
struct vector0 : sequence_base<vector0>
{
typedef mpl::vector0<> types;
typedef vector_tag fusion_tag;
typedef fusion_sequence_tag tag; // this gets picked up by MPL
typedef mpl::false_ is_view;
typedef random_access_traversal_tag category;
typedef mpl::int_<0> size;
vector0() {}
template<typename Sequence>
vector0(Sequence const& seq)
{}
};
// expand vector1 to vector10
#define BOOST_PP_FILENAME_1 <boost/fusion/container/vector/detail/vector_n.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, 10)
#include BOOST_PP_ITERATE()
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/vector_fwd.hpp
externo
-25
Ver Arquivo
@@ -1,25 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VECTOR_FORWARD_07072005_0125)
#define FUSION_VECTOR_FORWARD_07072005_0125
#include <boost/fusion/container/vector/limits.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
namespace boost { namespace fusion
{
struct void_;
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename T, void_)
>
struct vector;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/container/vector/vector_iterator.hpp
externo
-46
Ver Arquivo
@@ -1,46 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VECTOR_ITERATOR_05042005_0635)
#define FUSION_VECTOR_ITERATOR_05042005_0635
#include <boost/fusion/support/iterator_base.hpp>
#include <boost/fusion/container/vector/detail/deref_impl.hpp>
#include <boost/fusion/container/vector/detail/value_of_impl.hpp>
#include <boost/fusion/container/vector/detail/next_impl.hpp>
#include <boost/fusion/container/vector/detail/prior_impl.hpp>
#include <boost/fusion/container/vector/detail/equal_to_impl.hpp>
#include <boost/fusion/container/vector/detail/distance_impl.hpp>
#include <boost/fusion/container/vector/detail/advance_impl.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/mpl/int.hpp>
namespace boost { namespace fusion
{
struct vector_iterator_tag;
struct random_access_traversal_tag;
template <typename Vector, int N>
struct vector_iterator_identity;
template <typename Vector, int N>
struct vector_iterator : iterator_base<vector_iterator<Vector, N> >
{
typedef mpl::int_<N> index;
typedef Vector vector;
typedef vector_iterator_tag fusion_tag;
typedef random_access_traversal_tag category;
typedef vector_iterator_identity<
typename add_const<Vector>::type, N> identity;
vector_iterator(Vector& vec)
: vec(vec) {}
Vector& vec;
};
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/include/std_pair.hpp
externo
-12
Ver Arquivo
@@ -1,12 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_INCLUDE_STD_PAIR)
#define FUSION_INCLUDE_STD_PAIR
#include <boost/fusion/adapted/std_pair.hpp>
#endif
third_party/boost/boost_1_36_0/boost/fusion/include/tuple.hpp
externo
-12
Ver Arquivo
@@ -1,12 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_INCLUDE_TUPLE)
#define FUSION_INCLUDE_TUPLE
#include <boost/fusion/tuple.hpp>
#endif
third_party/boost/boost_1_36_0/boost/fusion/iterator/deref.hpp
externo
-72
Ver Arquivo
@@ -1,72 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_DEREF_05042005_1019)
#define FUSION_DEREF_05042005_1019
#include <boost/fusion/support/iterator_base.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct iterator_facade_tag; // iterator facade tag
struct array_iterator_tag; // boost::array iterator tag
struct mpl_iterator_tag; // mpl sequence iterator tag
struct std_pair_iterator_tag; // std::pair iterator tag
namespace extension
{
template <typename Tag>
struct deref_impl
{
template <typename Iterator>
struct apply {};
};
template <>
struct deref_impl<iterator_facade_tag>
{
template <typename Iterator>
struct apply : Iterator::template deref<Iterator> {};
};
template <>
struct deref_impl<array_iterator_tag>;
template <>
struct deref_impl<mpl_iterator_tag>;
template <>
struct deref_impl<std_pair_iterator_tag>;
}
namespace result_of
{
template <typename Iterator>
struct deref
: extension::deref_impl<typename detail::tag_of<Iterator>::type>::
template apply<Iterator>
{};
}
template <typename Iterator>
typename result_of::deref<Iterator>::type
deref(Iterator const& i)
{
typedef result_of::deref<Iterator> deref_meta;
return deref_meta::call(i);
}
template <typename Iterator>
typename result_of::deref<Iterator>::type
operator*(iterator_base<Iterator> const& i)
{
return fusion::deref(i.cast());
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/iterator/detail/advance.hpp
externo
-102
Ver Arquivo
@@ -1,102 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_ADVANCE_09172005_1149)
#define FUSION_ADVANCE_09172005_1149
#include <boost/mpl/int.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/prior.hpp>
namespace boost { namespace fusion { namespace advance_detail
{
// Default advance implementation, perform next(i)
// or prior(i) N times.
template <typename Iterator, int N>
struct forward;
template <typename Iterator, int N>
struct next_forward
{
typedef typename
forward<
typename result_of::next<Iterator>::type
, N-1
>::type
type;
};
template <typename Iterator, int N>
struct forward
{
typedef typename
mpl::eval_if_c<
(N == 0)
, mpl::identity<Iterator>
, next_forward<Iterator, N>
>::type
type;
static type const&
call(type const& i)
{
return i;
}
template <typename I>
static type
call(I const& i)
{
return call(fusion::next(i));
}
};
template <typename Iterator, int N>
struct backward;
template <typename Iterator, int N>
struct next_backward
{
typedef typename
backward<
typename result_of::prior<Iterator>::type
, N+1
>::type
type;
};
template <typename Iterator, int N>
struct backward
{
typedef typename
mpl::eval_if_c<
(N == 0)
, mpl::identity<Iterator>
, next_backward<Iterator, N>
>::type
type;
static type const&
call(type const& i)
{
return i;
}
template <typename I>
static type
call(I const& i)
{
return call(fusion::prior(i));
}
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/iterator/equal_to.hpp
externo
-93
Ver Arquivo
@@ -1,93 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_EQUAL_TO_05052005_1208)
#define FUSION_EQUAL_TO_05052005_1208
#include <boost/type_traits/is_same.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/fusion/support/is_iterator.hpp>
#include <boost/mpl/and.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct iterator_facade_tag; // iterator facade tag
struct array_iterator_tag; // boost::array iterator tag
struct mpl_iterator_tag; // mpl sequence iterator tag
struct std_pair_iterator_tag; // std::pair iterator tag
namespace extension
{
template <typename Tag>
struct equal_to_impl
{
// default implementation
template <typename I1, typename I2>
struct apply
: is_same<typename add_const<I1>::type, typename add_const<I2>::type>
{};
};
template <>
struct equal_to_impl<iterator_facade_tag>
{
template <typename I1, typename I2>
struct apply : I1::template equal_to<I1, I2> {};
};
template <>
struct equal_to_impl<array_iterator_tag>;
template <>
struct equal_to_impl<mpl_iterator_tag>;
template <>
struct equal_to_impl<std_pair_iterator_tag>;
}
namespace result_of
{
template <typename I1, typename I2>
struct equal_to
: extension::equal_to_impl<typename detail::tag_of<I1>::type>::
template apply<I1, I2>
{};
}
namespace iterator_operators
{
template <typename Iter1, typename Iter2>
inline typename
enable_if<
mpl::and_<is_fusion_iterator<Iter1>, is_fusion_iterator<Iter2> >
, bool
>::type
operator==(Iter1 const&, Iter2 const&)
{
return result_of::equal_to<Iter1, Iter2>::value;
}
template <typename Iter1, typename Iter2>
inline typename
enable_if<
mpl::and_<is_fusion_iterator<Iter1>, is_fusion_iterator<Iter2> >
, bool
>::type
operator!=(Iter1 const&, Iter2 const&)
{
return !result_of::equal_to<Iter1, Iter2>::value;
}
}
using iterator_operators::operator==;
using iterator_operators::operator!=;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/iterator/iterator_facade.hpp
externo
-50
Ver Arquivo
@@ -1,50 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_ITERATOR_FACADE_09252006_1011)
#define FUSION_ITERATOR_FACADE_09252006_1011
#include <boost/fusion/support/iterator_base.hpp>
#include <boost/fusion/iterator/detail/advance.hpp>
#include <boost/fusion/support/category_of.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/assert.hpp>
namespace boost { namespace fusion
{
struct iterator_facade_tag;
template <typename Derived, typename Category>
struct iterator_facade : iterator_base<Derived>
{
typedef iterator_facade_tag fusion_tag;
typedef Derived derived_type;
typedef Category category;
// default implementation
template <typename I1, typename I2>
struct equal_to // default implementation
: is_same<
typename I1::derived_type
, typename I2::derived_type
>
{};
// default implementation
template <typename Iterator, typename N>
struct advance :
mpl::if_c<
(N::value > 0)
, advance_detail::forward<Iterator, N::value>
, advance_detail::backward<Iterator, N::value>
>::type
{
BOOST_MPL_ASSERT_NOT((traits::is_random_access<Iterator>));
};
};
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/iterator/next.hpp
externo
-63
Ver Arquivo
@@ -1,63 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_NEXT_05042005_1101)
#define FUSION_NEXT_05042005_1101
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct iterator_facade_tag; // iterator facade tag
struct array_iterator_tag; // boost::array iterator tag
struct mpl_iterator_tag; // mpl sequence iterator tag
struct std_pair_iterator_tag; // std::pair iterator tag
namespace extension
{
template <typename Tag>
struct next_impl
{
template <typename Iterator>
struct apply {};
};
template <>
struct next_impl<iterator_facade_tag>
{
template <typename Iterator>
struct apply : Iterator::template next<Iterator> {};
};
template <>
struct next_impl<array_iterator_tag>;
template <>
struct next_impl<mpl_iterator_tag>;
template <>
struct next_impl<std_pair_iterator_tag>;
}
namespace result_of
{
template <typename Iterator>
struct next
: extension::next_impl<typename detail::tag_of<Iterator>::type>::
template apply<Iterator>
{};
}
template <typename Iterator>
typename result_of::next<Iterator>::type const
next(Iterator const& i)
{
return result_of::next<Iterator>::call(i);
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/iterator/prior.hpp
externo
-63
Ver Arquivo
@@ -1,63 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_PRIOR_05042005_1144)
#define FUSION_PRIOR_05042005_1144
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct iterator_facade_tag; // iterator facade tag
struct array_iterator_tag; // boost::array iterator tag
struct mpl_iterator_tag; // mpl sequence iterator tag
struct std_pair_iterator_tag; // std::pair iterator tag
namespace extension
{
template <typename Tag>
struct prior_impl
{
template <typename Iterator>
struct apply {};
};
template <>
struct prior_impl<iterator_facade_tag>
{
template <typename Iterator>
struct apply : Iterator::template prior<Iterator> {};
};
template <>
struct prior_impl<array_iterator_tag>;
template <>
struct prior_impl<mpl_iterator_tag>;
template <>
struct prior_impl<std_pair_iterator_tag>;
}
namespace result_of
{
template <typename Iterator>
struct prior
: extension::prior_impl<typename detail::tag_of<Iterator>::type>::
template apply<Iterator>
{};
}
template <typename Iterator>
typename result_of::prior<Iterator>::type const
prior(Iterator const& i)
{
return result_of::prior<Iterator>::call(i);
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison.hpp
externo
-17
Ver Arquivo
@@ -1,17 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_SEQUENCE_COMPARISON_10022005_0615)
#define FUSION_SEQUENCE_COMPARISON_10022005_0615
#include <boost/fusion/sequence/comparison/equal_to.hpp>
#include <boost/fusion/sequence/comparison/greater.hpp>
#include <boost/fusion/sequence/comparison/greater_equal.hpp>
#include <boost/fusion/sequence/comparison/less.hpp>
#include <boost/fusion/sequence/comparison/less_equal.hpp>
#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
externo
-38
Ver Arquivo
@@ -1,38 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_ENABLE_COMPARISON_09232005_1958)
#define FUSION_ENABLE_COMPARISON_09232005_1958
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Sequence>
struct is_native_fusion_sequence : is_base_of<sequence_root, Sequence> {};
template <typename Seq1, typename Seq2>
struct enable_equality
: mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
{};
template <typename Seq1, typename Seq2>
struct enable_comparison
: mpl::and_<
mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
, mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> >
>
{};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/detail/equal_to.hpp
externo
-60
Ver Arquivo
@@ -1,60 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_EQUAL_TO_05052005_1142)
#define FUSION_EQUAL_TO_05052005_1142
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2, bool same_size>
struct sequence_equal_to
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return true;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a == *b
&& call(fusion::next(a), fusion::next(b));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
template <typename Seq1, typename Seq2>
struct sequence_equal_to<Seq1, Seq2, false>
{
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
return false;
}
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/detail/less.hpp
externo
-50
Ver Arquivo
@@ -1,50 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_LESS_05052005_1141)
#define FUSION_LESS_05052005_1141
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2>
struct sequence_less
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return false;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a < *b
|| !(*b < *a)
&& call(fusion::next(a), fusion::next(b));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/equal_to.hpp
externo
-46
Ver Arquivo
@@ -1,46 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_EQUAL_TO_05052005_0431)
#define FUSION_EQUAL_TO_05052005_0431
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
equal_to(Seq1 const& a, Seq2 const& b)
{
return result_of::size<Seq1>::value == result_of::size<Seq2>::value
&& detail::sequence_equal_to<
Seq1 const, Seq2 const
, result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
call(fusion::begin(a), fusion::begin(b));
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_equality<Seq1, Seq2>
, bool
>::type
operator==(Seq1 const& a, Seq2 const& b)
{
return fusion::equal_to(a, b);
}
}
using operators::operator==;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/greater.hpp
externo
-52
Ver Arquivo
@@ -1,52 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_GREATER_05052005_0432)
#define FUSION_GREATER_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/greater.hpp>
#else
#include <boost/fusion/sequence/comparison/less.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
greater(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return detail::sequence_greater<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
#else
return (b < a);
#endif
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator>(Seq1 const& a, Seq2 const& b)
{
return fusion::greater(a, b);
}
}
using operators::operator>;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/greater_equal.hpp
externo
-52
Ver Arquivo
@@ -1,52 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_GREATER_EQUAL_05052005_0432)
#define FUSION_GREATER_EQUAL_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/greater_equal.hpp>
#else
#include <boost/fusion/sequence/comparison/less.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
greater_equal(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return detail::sequence_greater_equal<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
#else
return !(a < b);
#endif
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator>=(Seq1 const& a, Seq2 const& b)
{
return fusion::greater_equal(a, b);
}
}
using operators::operator>=;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/less.hpp
externo
-43
Ver Arquivo
@@ -1,43 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_LESS_05052005_0432)
#define FUSION_LESS_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/less.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
less(Seq1 const& a, Seq2 const& b)
{
return detail::sequence_less<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator<(Seq1 const& a, Seq2 const& b)
{
return fusion::less(a, b);
}
}
using operators::operator<;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/less_equal.hpp
externo
-80
Ver Arquivo
@@ -1,80 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_LESS_EQUAL_05052005_0432)
#define FUSION_LESS_EQUAL_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/less_equal.hpp>
#else
#include <boost/fusion/sequence/comparison/less.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
less_equal(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return detail::sequence_less_equal<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
#else
return !(b < a);
#endif
}
namespace operators
{
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1400)
// Workaround for VC8.0 and VC7.1
template <typename Seq1, typename Seq2>
inline bool
operator<=(sequence_base<Seq1> const& a, sequence_base<Seq2> const& b)
{
return less_equal(a.derived(), b.derived());
}
template <typename Seq1, typename Seq2>
inline typename disable_if<detail::is_native_fusion_sequence<Seq2>, bool>::type
operator<=(sequence_base<Seq1> const& a, Seq2 const& b)
{
return less_equal(a.derived(), b);
}
template <typename Seq1, typename Seq2>
inline typename disable_if<detail::is_native_fusion_sequence<Seq1>, bool>::type
operator<=(Seq1 const& a, sequence_base<Seq2> const& b)
{
return less_equal(a, b.derived());
}
#else
// Somehow VC8.0 and VC7.1 does not like this code
// but barfs somewhere else.
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator<=(Seq1 const& a, Seq2 const& b)
{
return fusion::less_equal(a, b);
}
#endif
}
using operators::operator<=;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/comparison/not_equal_to.hpp
externo
-55
Ver Arquivo
@@ -1,55 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_NOT_EQUAL_TO_05052005_0431)
#define FUSION_NOT_EQUAL_TO_05052005_0431
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/not_equal_to.hpp>
#else
#include <boost/fusion/sequence/comparison/equal_to.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
not_equal_to(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return result_of::size<Seq1>::value != result_of::size<Seq2>::value
|| detail::sequence_not_equal_to<
Seq1 const, Seq2 const
, result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
call(fusion::begin(a), fusion::begin(b));
#else
return !(a == b);
#endif
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_equality<Seq1, Seq2>
, bool
>::type
operator!=(Seq1 const& a, Seq2 const& b)
{
return fusion::not_equal_to(a, b);
}
}
using operators::operator!=;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/intrinsic/at.hpp
externo
-106
Ver Arquivo
@@ -1,106 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_AT_05042005_0722)
#define FUSION_AT_05042005_0722
#include <boost/mpl/int.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/fusion/support/detail/access.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename Tag>
struct at_impl
{
template <typename Sequence, typename N>
struct apply;
};
template <>
struct at_impl<sequence_facade_tag>
{
template <typename Sequence, typename N>
struct apply : Sequence::template at<Sequence, N> {};
};
template <>
struct at_impl<boost_tuple_tag>;
template <>
struct at_impl<array_tag>;
template <>
struct at_impl<mpl_sequence_tag>;
template <>
struct at_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence, typename N>
struct at
: extension::at_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence, N>
{};
template <typename Sequence, int N>
struct at_c
: at<Sequence, mpl::int_<N> >
{};
}
template <typename N, typename Sequence>
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::at<Sequence, N>
>::type
at(Sequence& seq)
{
return result_of::at<Sequence, N>::call(seq);
}
template <typename N, typename Sequence>
inline typename result_of::at<Sequence const, N>::type
at(Sequence const& seq)
{
return result_of::at<Sequence const, N>::call(seq);
}
template <int N, typename Sequence>
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::at_c<Sequence, N>
>::type
at_c(Sequence& seq)
{
return at<mpl::int_<N> >(seq);
}
template <int N, typename Sequence>
inline typename result_of::at_c<Sequence const, N>::type
at_c(Sequence const& seq)
{
return at<mpl::int_<N> >(seq);
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/intrinsic/begin.hpp
externo
-74
Ver Arquivo
@@ -1,74 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_BEGIN_04052005_1132)
#define FUSION_BEGIN_04052005_1132
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag; // iterator facade tag
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename Tag>
struct begin_impl
{
template <typename Sequence>
struct apply;
};
template <>
struct begin_impl<sequence_facade_tag>
{
template <typename Sequence>
struct apply : Sequence::template begin<Sequence> {};
};
template <>
struct begin_impl<boost_tuple_tag>;
template <>
struct begin_impl<array_tag>;
template <>
struct begin_impl<mpl_sequence_tag>;
template <>
struct begin_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence>
struct begin
: extension::begin_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence>
{};
}
template <typename Sequence>
inline typename result_of::begin<Sequence>::type const
begin(Sequence& seq)
{
return result_of::begin<Sequence>::call(seq);
}
template <typename Sequence>
inline typename result_of::begin<Sequence const>::type const
begin(Sequence const& seq)
{
return result_of::begin<Sequence const>::call(seq);
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/intrinsic/end.hpp
externo
-74
Ver Arquivo
@@ -1,74 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_END_04052005_1141)
#define FUSION_END_04052005_1141
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename Tag>
struct end_impl
{
template <typename Sequence>
struct apply;
};
template <>
struct end_impl<sequence_facade_tag>
{
template <typename Sequence>
struct apply : Sequence::template end<Sequence> {};
};
template <>
struct end_impl<boost_tuple_tag>;
template <>
struct end_impl<array_tag>;
template <>
struct end_impl<mpl_sequence_tag>;
template <>
struct end_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence>
struct end
: extension::end_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence>
{};
}
template <typename Sequence>
inline typename result_of::end<Sequence>::type const
end(Sequence& seq)
{
return result_of::end<Sequence>::call(seq);
}
template <typename Sequence>
inline typename result_of::end<Sequence const>::type const
end(Sequence const& seq)
{
return result_of::end<Sequence const>::call(seq);
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/intrinsic/size.hpp
externo
-74
Ver Arquivo
@@ -1,74 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_SIZE_05052005_0214)
#define FUSION_SIZE_05052005_0214
#include <boost/mpl/int.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename Tag>
struct size_impl
{
template <typename Sequence>
struct apply : Sequence::size {};
};
template <>
struct size_impl<sequence_facade_tag>
{
template <typename Sequence>
struct apply : Sequence::template size<Sequence> {};
};
template <>
struct size_impl<boost_tuple_tag>;
template <>
struct size_impl<array_tag>;
template <>
struct size_impl<mpl_sequence_tag>;
template <>
struct size_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence>
struct size
: extension::size_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence>
{
typedef typename extension::size_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence>::type size_application;
BOOST_STATIC_CONSTANT(int, value = size_application::value);
};
}
template <typename Sequence>
inline typename result_of::size<Sequence>::type
size(Sequence const&)
{
typedef typename result_of::size<Sequence>::type result;
return result();
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/intrinsic/value_at.hpp
externo
-67
Ver Arquivo
@@ -1,67 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_VALUE_AT_05052005_0229)
#define FUSION_VALUE_AT_05052005_0229
#include <boost/mpl/int.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename Tag>
struct value_at_impl
{
template <typename Sequence, typename N>
struct apply;
};
template <>
struct value_at_impl<sequence_facade_tag>
{
template <typename Sequence, typename N>
struct apply : Sequence::template value_at<Sequence, N> {};
};
template <>
struct value_at_impl<boost_tuple_tag>;
template <>
struct value_at_impl<array_tag>;
template <>
struct value_at_impl<mpl_sequence_tag>;
template <>
struct value_at_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence, typename N>
struct value_at
: extension::value_at_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence, N>
{};
template <typename Sequence, int N>
struct value_at_c
: fusion::result_of::value_at<Sequence, mpl::int_<N> >
{};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/io.hpp
externo
-13
Ver Arquivo
@@ -1,13 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_SEQUENCE_IO_10032005_0836)
#define FUSION_SEQUENCE_IO_10032005_0836
#include <boost/fusion/sequence/io/in.hpp>
#include <boost/fusion/sequence/io/out.hpp>
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/io/detail/in.hpp
externo
-85
Ver Arquivo
@@ -1,85 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_IN_05052005_0121)
#define FUSION_IN_05052005_0121
#include <istream>
#include <boost/fusion/sequence/io/detail/manip.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Tag>
struct delimiter_in
{
// read a delimiter
template <typename IS>
static void
read(IS& is, char const* delim, mpl::false_ = mpl::false_())
{
detail::string_ios_manip<Tag, IS> manip(is);
manip.read(delim);
}
template <typename IS>
static void
read(IS& is, char const* delim, mpl::true_)
{
}
};
struct read_sequence_loop
{
template <typename IS, typename First, typename Last>
static void
call(IS& is, First const&, Last const&, mpl::true_)
{
}
template <typename IS, typename First, typename Last>
static void
call(IS& is, First const& first, Last const& last, mpl::false_)
{
result_of::equal_to<
typename result_of::next<First>::type
, Last
>
is_last;
is >> *first;
delimiter_in<tuple_delimiter_tag>::read(is, " ", is_last);
call(is, fusion::next(first), last, is_last);
}
template <typename IS, typename First, typename Last>
static void
call(IS& is, First const& first, Last const& last)
{
result_of::equal_to<First, Last> eq;
call(is, first, last, eq);
}
};
template <typename IS, typename Sequence>
inline void
read_sequence(IS& is, Sequence& seq)
{
delimiter_in<tuple_open_tag>::read(is, "(");
read_sequence_loop::call(is, fusion::begin(seq), fusion::end(seq));
delimiter_in<tuple_close_tag>::read(is, ")");
}
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/io/detail/manip.hpp
externo
-316
Ver Arquivo
@@ -1,316 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_MANIP_05052005_1200)
#define FUSION_MANIP_05052005_1200
#include <boost/config.hpp>
#include <string>
#include <vector>
#include <cctype>
// Tuple I/O manipulators
#define FUSION_GET_CHAR_TYPE(T) typename T::char_type
#define FUSION_GET_TRAITS_TYPE(T) typename T::traits_type
#if defined (BOOST_NO_TEMPLATED_STREAMS)
#define FUSION_STRING_OF_STREAM(Stream) std::string
#else
#define FUSION_STRING_OF_STREAM(Stream) \
std::basic_string< \
FUSION_GET_CHAR_TYPE(Stream) \
, FUSION_GET_TRAITS_TYPE(Stream) \
>
#endif
//$$$ these should be part of the public API$$$
//$$$ rename tuple_open, tuple_close and tuple_delimiter to
// open, close and delimeter and add these synonyms to the
// TR1 tuple module.
namespace boost { namespace fusion
{
namespace detail
{
template <typename Tag>
int get_xalloc_index(Tag* = 0)
{
// each Tag will have a unique index
static int index = std::ios::xalloc();
return index;
}
template <typename Stream, typename Tag, typename T>
struct stream_data
{
struct arena
{
~arena()
{
for (
typename std::vector<T*>::iterator i = data.begin()
; i != data.end()
; ++i)
{
delete *i;
}
}
std::vector<T*> data;
};
static void attach(Stream& stream, T const& data)
{
static arena ar; // our arena
ar.data.push_back(new T(data));
stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
}
static T const* get(Stream& stream)
{
return (T const*)stream.pword(get_xalloc_index<Tag>());
}
};
template <typename Tag, typename Stream>
class string_ios_manip
{
public:
typedef FUSION_STRING_OF_STREAM(Stream) string_type;
typedef stream_data<Stream, Tag, string_type> stream_data_t;
string_ios_manip(Stream& str_)
: stream(str_)
{}
void
set(string_type const& s)
{
stream_data_t::attach(stream, s);
}
void
print(char const* default_) const
{
// print a delimiter
string_type const* p = stream_data_t::get(stream);
if (p)
stream << *p;
else
stream << default_;
}
void
read(char const* default_) const
{
// read a delimiter
string_type const* p = stream_data_t::get(stream);
using namespace std;
ws(stream);
if (p)
{
typedef typename string_type::const_iterator iterator;
for (iterator i = p->begin(); i != p->end(); ++i)
check_delim(*i);
}
else
{
while (*default_)
check_delim(*default_++);
}
}
private:
template <typename Char>
void
check_delim(Char c) const
{
if (!isspace(c))
{
if (stream.get() != c)
{
stream.unget();
stream.setstate(std::ios::failbit);
}
}
}
Stream& stream;
};
} // detail
#if defined (BOOST_NO_TEMPLATED_STREAMS)
#define STD_TUPLE_DEFINE_MANIPULATOR(name) \
namespace detail \
{ \
struct name##_tag; \
\
struct name##_type \
{ \
typedef std::string string_type; \
string_type data; \
name##_type(const string_type& d): data(d) {} \
}; \
\
template <typename Stream> \
Stream& operator>>(Stream& s, const name##_type& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
\
template <typename Stream> \
Stream& operator<<(Stream& s, const name##_type& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
}
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
inline detail::name##_type \
name(const std::string& s) \
{ \
return detail::name##_type(s); \
} \
\
inline detail::name##_type \
name(const char* s) \
{ \
return detail::name##_type(std::string(s)); \
} \
\
inline detail::name##_type \
name(char c) \
{ \
return detail::name##_type(std::string(1, c)); \
}
#else // defined(BOOST_NO_TEMPLATED_STREAMS)
#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
template <typename Char, typename Traits> \
inline detail::name##_type<Char, Traits> \
name(const std::basic_string<Char, Traits>& s) \
{ \
return detail::name##_type<Char, Traits>(s); \
} \
\
inline detail::name##_type<char> \
name(char const* s) \
{ \
return detail::name##_type<char>(std::basic_string<char>(s)); \
} \
\
inline detail::name##_type<wchar_t> \
name(wchar_t const* s) \
{ \
return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(s)); \
} \
\
inline detail::name##_type<char> \
name(char c) \
{ \
return detail::name##_type<char>(std::basic_string<char>(1, c)); \
} \
\
inline detail::name##_type<wchar_t> \
name(wchar_t c) \
{ \
return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(1, c)); \
}
#else // defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
template <typename Char, typename Traits> \
inline detail::name##_type<Char, Traits> \
name(const std::basic_string<Char, Traits>& s) \
{ \
return detail::name##_type<Char, Traits>(s); \
} \
\
template <typename Char> \
inline detail::name##_type<Char> \
name(Char s[]) \
{ \
return detail::name##_type<Char>(std::basic_string<Char>(s)); \
} \
\
template <typename Char> \
inline detail::name##_type<Char> \
name(Char const s[]) \
{ \
return detail::name##_type<Char>(std::basic_string<Char>(s)); \
} \
\
template <typename Char> \
inline detail::name##_type<Char> \
name(Char c) \
{ \
return detail::name##_type<Char>(std::basic_string<Char>(1, c)); \
}
#endif
#define STD_TUPLE_DEFINE_MANIPULATOR(name) \
namespace detail \
{ \
struct name##_tag; \
\
template <typename Char, typename Traits = std::char_traits<Char> > \
struct name##_type \
{ \
typedef std::basic_string<Char, Traits> string_type; \
string_type data; \
name##_type(const string_type& d): data(d) {} \
}; \
\
template <typename Stream, typename Char, typename Traits> \
Stream& operator>>(Stream& s, const name##_type<Char,Traits>& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
\
template <typename Stream, typename Char, typename Traits> \
Stream& operator<<(Stream& s, const name##_type<Char,Traits>& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
} \
#endif // defined(BOOST_NO_TEMPLATED_STREAMS)
STD_TUPLE_DEFINE_MANIPULATOR(tuple_open)
STD_TUPLE_DEFINE_MANIPULATOR(tuple_close)
STD_TUPLE_DEFINE_MANIPULATOR(tuple_delimiter)
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_open)
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_close)
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_delimiter)
#undef STD_TUPLE_DEFINE_MANIPULATOR
#undef STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS
#undef FUSION_STRING_OF_STREAM
#undef FUSION_GET_CHAR_TYPE
#undef FUSION_GET_TRAITS_TYPE
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/io/detail/out.hpp
externo
-85
Ver Arquivo
@@ -1,85 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_OUT_05052005_0121)
#define FUSION_OUT_05052005_0121
#include <ostream>
#include <boost/fusion/sequence/io/detail/manip.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Tag>
struct delimiter_out
{
// print a delimiter
template <typename OS>
static void
print(OS& os, char const* delim, mpl::false_ = mpl::false_())
{
detail::string_ios_manip<Tag, OS> manip(os);
manip.print(delim);
}
template <typename OS>
static void
print(OS& os, char const* delim, mpl::true_)
{
}
};
struct print_sequence_loop
{
template <typename OS, typename First, typename Last>
static void
call(OS& os, First const&, Last const&, mpl::true_)
{
}
template <typename OS, typename First, typename Last>
static void
call(OS& os, First const& first, Last const& last, mpl::false_)
{
result_of::equal_to<
typename result_of::next<First>::type
, Last
>
is_last;
os << *first;
delimiter_out<tuple_delimiter_tag>::print(os, " ", is_last);
call(os, fusion::next(first), last, is_last);
}
template <typename OS, typename First, typename Last>
static void
call(OS& os, First const& first, Last const& last)
{
result_of::equal_to<First, Last> eq;
call(os, first, last, eq);
}
};
template <typename OS, typename Sequence>
inline void
print_sequence(OS& os, Sequence const& seq)
{
delimiter_out<tuple_open_tag>::print(os, "(");
print_sequence_loop::call(os, fusion::begin(seq), fusion::end(seq));
delimiter_out<tuple_close_tag>::print(os, ")");
}
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/io/in.hpp
externo
-42
Ver Arquivo
@@ -1,42 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_IN_05042005_0120)
#define BOOST_IN_05042005_0120
#include <istream>
#include <boost/fusion/sequence/io/detail/in.hpp>
#include <boost/fusion/support/is_sequence.hpp>
namespace boost { namespace fusion
{
template <typename Sequence>
inline std::istream&
in(std::istream& is, Sequence& seq)
{
detail::read_sequence(is, seq);
return is;
}
namespace operators
{
template <typename Sequence>
inline typename
enable_if<
fusion::traits::is_sequence<Sequence>
, std::istream&
>::type
operator>>(std::istream& is, Sequence& seq)
{
return fusion::in(is, seq);
}
}
using operators::operator>>;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/sequence/io/out.hpp
externo
-44
Ver Arquivo
@@ -1,44 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_OUT_05042005_0120)
#define BOOST_OUT_05042005_0120
#include <ostream>
#include <boost/fusion/sequence/io/detail/out.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/or.hpp>
namespace boost { namespace fusion
{
template <typename Sequence>
inline std::ostream&
out(std::ostream& os, Sequence& seq)
{
detail::print_sequence(os, seq);
return os;
}
namespace operators
{
template <typename Sequence>
inline typename
enable_if<
fusion::traits::is_sequence<Sequence>
, std::ostream&
>::type
operator<<(std::ostream& os, Sequence const& seq)
{
return fusion::out(os, seq);
}
}
using operators::operator<<;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/category_of.hpp
externo
-112
Ver Arquivo
@@ -1,112 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_CATEGORY_OF_07202005_0308)
#define FUSION_CATEGORY_OF_07202005_0308
#include <boost/fusion/support/detail/category_of.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/type_traits/is_base_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
struct incrementable_traversal_tag {};
struct single_pass_traversal_tag
: incrementable_traversal_tag {};
struct forward_traversal_tag
: single_pass_traversal_tag {};
struct bidirectional_traversal_tag
: forward_traversal_tag {};
struct random_access_traversal_tag
: bidirectional_traversal_tag {};
struct associative_sequence_tag {};
namespace extension
{
template<typename Tag>
struct category_of_impl
{
template<typename T>
struct apply : detail::fusion_category_of<T> {};
};
template <>
struct category_of_impl<boost_tuple_tag>;
template <>
struct category_of_impl<array_tag>;
template <>
struct category_of_impl<mpl_sequence_tag>;
template <>
struct category_of_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct category_of
: extension::category_of_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>
{};
template <typename T>
struct is_associative
: is_base_of<
associative_sequence_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_incrementable
: is_base_of<
incrementable_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_single_pass
: is_base_of<
single_pass_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_forward
: is_base_of<
forward_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_bidirectional
: is_base_of<
bidirectional_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_random_access
: is_base_of<
random_access_traversal_tag
, typename category_of<T>::type>
{};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/detail/access.hpp
externo
-55
Ver Arquivo
@@ -1,55 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_ACCESS_04182005_0737)
#define FUSION_ACCESS_04182005_0737
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_cv.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct ref_result
{
typedef typename add_reference<typename T::type>::type type;
};
template <typename T>
struct cref_result
{
typedef typename
add_reference<
typename add_const<typename T::type>::type
>::type
type;
};
template <typename T>
struct non_ref_parameter
{
typedef typename boost::remove_cv<T>::type const& type;
};
template <typename T>
struct call_param
{
typedef typename
mpl::eval_if<
is_reference<T>
, mpl::identity<T>
, non_ref_parameter<T>
>::type
type;
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/detail/as_fusion_element.hpp
externo
-47
Ver Arquivo
@@ -1,47 +0,0 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_AS_FUSION_ELEMENT_05052005_0338)
#define FUSION_AS_FUSION_ELEMENT_05052005_0338
#include <boost/ref.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct as_fusion_element
{
typedef T type;
};
template <typename T>
struct as_fusion_element<reference_wrapper<T> >
{
typedef T& type;
};
template <typename T, int N>
struct as_fusion_element<T[N]>
{
typedef const T(&type)[N];
};
template <typename T, int N>
struct as_fusion_element<volatile T[N]>
{
typedef const volatile T(&type)[N];
};
template <typename T, int N>
struct as_fusion_element<const volatile T[N]>
{
typedef const volatile T(&type)[N];
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/detail/category_of.hpp
externo
-19
Ver Arquivo
@@ -1,19 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_CATEGORY_OF_07212005_1025)
#define FUSION_CATEGORY_OF_07212005_1025
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_category_of
{
typedef typename T::category type;
};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/detail/is_mpl_sequence.hpp
externo
-27
Ver Arquivo
@@ -1,27 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105)
#define FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct is_mpl_sequence
: mpl::and_<
mpl::not_<is_base_of<sequence_root, T> >
, mpl::is_sequence<T> >
{};
}}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/is_iterator.hpp
externo
-20
Ver Arquivo
@@ -1,20 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_IS_ITERATOR_05062005_1219)
#define FUSION_IS_ITERATOR_05062005_1219
#include <boost/type_traits/is_base_of.hpp>
namespace boost { namespace fusion
{
struct iterator_root;
template <typename T>
struct is_fusion_iterator : is_base_of<iterator_root, T> {};
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/is_sequence.hpp
externo
-65
Ver Arquivo
@@ -1,65 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_IS_SEQUENCE_05052005_1002)
#define FUSION_IS_SEQUENCE_05052005_1002
#include <boost/type_traits/is_base_of.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct non_fusion_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename T>
struct is_sequence_impl
{
template <typename Sequence>
struct apply : is_base_of<sequence_root, Sequence> {};
};
template <>
struct is_sequence_impl<non_fusion_tag>
{
template <typename T>
struct apply : mpl::false_ {};
};
template <>
struct is_sequence_impl<boost_tuple_tag>;
template <>
struct is_sequence_impl<array_tag>;
template <>
struct is_sequence_impl<mpl_sequence_tag>;
template <>
struct is_sequence_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct is_sequence
: extension::is_sequence_impl<typename detail::tag_of<T>::type>::
template apply<T>
{};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/iterator_base.hpp
externo
-31
Ver Arquivo
@@ -1,31 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_ITERATOR_BASE_05042005_1008)
#define FUSION_ITERATOR_BASE_05042005_1008
namespace boost { namespace fusion
{
struct iterator_root {};
template <typename Iterator>
struct iterator_base : iterator_root
{
Iterator const&
cast() const
{
return static_cast<Iterator const&>(*this);
}
Iterator&
cast()
{
return static_cast<Iterator&>(*this);
}
};
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/sequence_base.hpp
externo
-45
Ver Arquivo
@@ -1,45 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2007 Tobias Schwinger
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_SEQUENCE_BASE_04182005_0737)
#define FUSION_SEQUENCE_BASE_04182005_0737
#include <boost/mpl/begin_end_fwd.hpp>
namespace boost { namespace fusion
{
struct sequence_root {};
template <typename Sequence>
struct sequence_base : sequence_root
{
Sequence const&
derived() const
{
return static_cast<Sequence const&>(*this);
}
Sequence&
derived()
{
return static_cast<Sequence&>(*this);
}
};
struct fusion_sequence_tag;
}}
namespace boost { namespace mpl
{
// Deliberately break mpl::begin, so it doesn't lie that a Fusion sequence
// is not an MPL sequence by returning mpl::void_.
// In other words: Fusion Sequences are always MPL Sequences, but they can
// be incompletely defined.
template<> struct begin_impl< boost::fusion::fusion_sequence_tag >;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/tag_of.hpp
externo
-110
Ver Arquivo
@@ -1,110 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_TAG_OF_09232005_0845)
#define FUSION_TAG_OF_09232005_0845
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost
{
template <typename T, std::size_t N>
class array; // forward
namespace tuples
{
struct null_type;
template <
class T0, class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8, class T9
>
class tuple;
template <class Head, class Tail>
struct cons;
}
}
namespace boost { namespace fusion
{
struct non_fusion_tag;
struct mpl_sequence_tag;
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF(fusion_tag)
template<typename Sequence>
struct is_specialized
: mpl::false_
{};
template <
class T0, class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8, class T9
>
struct is_specialized<tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
: mpl::true_
{};
template <class Head, class Tail>
struct is_specialized<tuples::cons<Head, Tail> >
: mpl::true_
{};
template <>
struct is_specialized<tuples::null_type>
: mpl::true_
{};
template <typename T, std::size_t N>
struct is_specialized<boost::array<T, N> >
: mpl::true_
{};
template<typename T1, typename T2>
struct is_specialized<std::pair<T1, T2> >
: mpl::true_
{};
}
namespace traits
{
template <typename Sequence, typename Active>
struct tag_of
: mpl::if_< detail::is_mpl_sequence<Sequence>,
mpl::identity<mpl_sequence_tag>,
mpl::identity<non_fusion_tag> >::type
{
BOOST_MPL_ASSERT_NOT((detail::is_specialized<Sequence>));
};
template <typename Sequence>
struct tag_of<Sequence, typename boost::enable_if<detail::has_fusion_tag<Sequence> >::type>
{
typedef typename Sequence::fusion_tag type;
};
}
namespace detail
{
template<typename T>
struct tag_of
: traits::tag_of<typename remove_const<T>::type>
{};
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/support/tag_of_fwd.hpp
externo
-20
Ver Arquivo
@@ -1,20 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_TAG_OF_FWD_31122005_1445)
#define BOOST_FUSION_TAG_OF_FWD_31122005_1445
namespace boost { namespace fusion
{
namespace traits
{
template<typename T, typename Active = void>
struct tag_of;
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/tuple.hpp
externo
-15
Ver Arquivo
@@ -1,15 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_TUPLE_10032005_0806)
#define FUSION_TUPLE_10032005_0806
#include <boost/fusion/tuple/tuple.hpp>
#include <boost/fusion/tuple/make_tuple.hpp>
#include <boost/fusion/tuple/tuple_tie.hpp>
#include <boost/fusion/container/generation/ignore.hpp>
#endif
third_party/boost/boost_1_36_0/boost/fusion/tuple/detail/tuple_forward_ctor.hpp
externo
-39
Ver Arquivo
@@ -1,39 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_TUPLE_FORWARD_CTOR_10032005_0815)
#define FUSION_TUPLE_FORWARD_CTOR_10032005_0815
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define BOOST_PP_FILENAME_1 \
<boost/fusion/tuple/detail/tuple_forward_ctor.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
#if N == 1
explicit
#endif
tuple(BOOST_PP_ENUM_BINARY_PARAMS(
N, typename detail::call_param<T, >::type _))
: base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
third_party/boost/boost_1_36_0/boost/fusion/tuple/make_tuple.hpp
externo
-56
Ver Arquivo
@@ -1,56 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAKE_TUPLE_10032005_0843)
#define FUSION_MAKE_TUPLE_10032005_0843
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/fusion/tuple/tuple.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
namespace boost { namespace fusion
{
inline tuple<>
make_tuple()
{
return tuple<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/tuple/make_tuple.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_AS_FUSION_ELEMENT
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline tuple<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_tuple(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return tuple<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
third_party/boost/boost_1_36_0/boost/fusion/tuple/tuple.hpp
externo
-72
Ver Arquivo
@@ -1,72 +0,0 @@
/*=============================================================================
Copyright (c) 2005 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_TUPLE_10032005_0810)
#define FUSION_TUPLE_10032005_0810
#include <boost/fusion/tuple/tuple_fwd.hpp>
#include <boost/fusion/container/vector/vector.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/intrinsic/value_at.hpp>
#include <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/fusion/sequence/comparison.hpp>
#include <boost/fusion/sequence/io.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_const.hpp>
namespace boost { namespace fusion
{
template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, typename T)>
struct tuple : vector<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>
{
typedef vector<
BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>
base_type;
tuple()
: base_type() {}
template <typename Sequence>
tuple(Sequence const& rhs)
: base_type(rhs) {}
#include <boost/fusion/tuple/detail/tuple_forward_ctor.hpp>
template <typename T>
tuple&
operator=(T const& rhs)
{
base_type::operator=(rhs);
return *this;
}
};
template <typename Tuple>
struct tuple_size : result_of::size<Tuple> {};
template <int N, typename Tuple>
struct tuple_element : result_of::value_at_c<Tuple, N> {};
template <int N, typename Tuple>
inline typename
lazy_disable_if<
is_const<Tuple>
, result_of::at_c<Tuple, N>
>::type
get(Tuple& tup)
{
return at_c<N>(tup);
}
template <int N, typename Tuple>
inline typename result_of::at_c<Tuple const, N>::type
get(Tuple const& tup)
{
return at_c<N>(tup);
}
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/tuple/tuple_fwd.hpp
externo
-24
Ver Arquivo
@@ -1,24 +0,0 @@
/*=============================================================================
Copyright (c) 2005 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_TUPLE_FORWARD_10032005_0956)
#define FUSION_TUPLE_FORWARD_10032005_0956
#include <boost/fusion/container/vector/limits.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
namespace boost { namespace fusion
{
struct void_;
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename T, void_)
>
struct tuple;
}}
#endif
third_party/boost/boost_1_36_0/boost/fusion/tuple/tuple_tie.hpp
externo
-49
Ver Arquivo
@@ -1,49 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_TUPLE_TIE_10032005_0846)
#define FUSION_TUPLE_TIE_10032005_0846
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/fusion/tuple/tuple.hpp>
namespace boost { namespace fusion
{
#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
#define BOOST_PP_FILENAME_1 <boost/fusion/tuple/tuple_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_REF
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline tuple<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return tuple<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
third_party/boost/boost_1_36_0/boost/mpl/advance.hpp
externo
-76
Ver Arquivo
@@ -1,76 +0,0 @@
#ifndef BOOST_MPL_ADVANCE_HPP_INCLUDED
#define BOOST_MPL_ADVANCE_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Source$
// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
// $Revision: 24874 $
#include <boost/mpl/advance_fwd.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/negate.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/tag.hpp>
#include <boost/mpl/apply_wrap.hpp>
#include <boost/mpl/aux_/advance_forward.hpp>
#include <boost/mpl/aux_/advance_backward.hpp>
#include <boost/mpl/aux_/value_wknd.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
namespace boost { namespace mpl {
// default implementation for forward/bidirectional iterators
template< typename Tag >
struct advance_impl
{
template< typename Iterator, typename N > struct apply
{
typedef typename less< N,long_<0> >::type backward_;
typedef typename if_< backward_, negate<N>, N >::type offset_;
typedef typename if_<
backward_
, aux::advance_backward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value >
, aux::advance_forward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value >
>::type f_;
typedef typename apply_wrap1<f_,Iterator>::type type;
};
};
template<
typename BOOST_MPL_AUX_NA_PARAM(Iterator)
, typename BOOST_MPL_AUX_NA_PARAM(N)
>
struct advance
: advance_impl< typename tag<Iterator>::type >
::template apply<Iterator,N>
{
};
template<
typename Iterator
, BOOST_MPL_AUX_NTTP_DECL(long, N)
>
struct advance_c
: advance_impl< typename tag<Iterator>::type >
::template apply<Iterator,long_<N> >
{
};
BOOST_MPL_AUX_NA_SPEC(2, advance)
}}
#endif // BOOST_MPL_ADVANCE_HPP_INCLUDED
third_party/boost/boost_1_36_0/boost/mpl/advance_fwd.hpp
externo
-28
Ver Arquivo
@@ -1,28 +0,0 @@
#ifndef BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
#define BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Source$
// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
// $Revision: 24874 $
#include <boost/mpl/aux_/common_name_wknd.hpp>
namespace boost { namespace mpl {
BOOST_MPL_AUX_COMMON_NAME_WKND(advance)
template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;
}}
#endif // BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED

Alguns arquivos não foram exibidos porque demasiados arquivos foram alterados neste diff Mostrar Mais