|
|
Boost-Commit : |
From: daniel_james_at_[hidden]
Date: 2008-02-07 13:54:22
Author: danieljames
Date: 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
New Revision: 43162
URL: http://svn.boost.org/trac/boost/changeset/43162
Log:
Merge.
Added:
branches/fix-links/libs/bimap/doc/html/boost_bimap/the_tutorial/additional_information.html
- copied unchanged from r43159, /trunk/libs/bimap/doc/html/boost_bimap/the_tutorial/additional_information.html
branches/fix-links/libs/math/doc/sf_and_dist/html/math_toolkit/main_overview/compilers_overview.html
- copied unchanged from r43159, /trunk/libs/math/doc/sf_and_dist/html/math_toolkit/main_overview/compilers_overview.html
branches/fix-links/tools/release/index.html
- copied unchanged from r43159, /trunk/tools/release/index.html
branches/fix-links/tools/release/inspect.sh
- copied unchanged from r43159, /trunk/tools/release/inspect.sh
branches/fix-links/tools/release/snapshot_posix.sh
- copied unchanged from r43159, /trunk/tools/release/snapshot_posix.sh
branches/fix-links/tools/release/snapshot_windows.sh
- copied unchanged from r43159, /trunk/tools/release/snapshot_windows.sh
Removed:
branches/fix-links/doc/html/boost_math.html
branches/fix-links/doc/html/boost_typetraits/
branches/fix-links/doc/html/boost_typetraits.html
branches/fix-links/libs/bimap/doc/html/boost_bimap/the_tutorial/hooking_information.html
branches/fix-links/libs/ptr_container/test/sequence_point.cpp
branches/fix-links/libs/range/test/TODO
branches/fix-links/libs/range/test/compat1.cpp
branches/fix-links/libs/type_traits/doc/html/boost_typetraits/category/background.html
branches/fix-links/tools/release/make_tarballs.py
branches/fix-links/tools/release/utils.py
Properties modified:
branches/fix-links/ (props changed)
Binary files modified:
branches/fix-links/libs/range/doc/Jamfile.v2
Text files modified:
branches/fix-links/boost/config/compiler/sunpro_cc.hpp | 4
branches/fix-links/boost/function_types/detail/cv_traits.hpp | 8
branches/fix-links/boost/graph/compressed_sparse_row_graph.hpp | 2
branches/fix-links/boost/graph/detail/indexed_properties.hpp | 3
branches/fix-links/boost/range/iterator_range.hpp | 13
branches/fix-links/boost/range/sub_range.hpp | 12
branches/fix-links/boost/thread/win32/basic_recursive_mutex.hpp | 6
branches/fix-links/boost/thread/win32/basic_timed_mutex.hpp | 6
branches/fix-links/boost/xpressive/detail/core/matcher/action_matcher.hpp | 12
branches/fix-links/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp | 2
branches/fix-links/boost/xpressive/detail/core/matcher/attr_matcher.hpp | 2
branches/fix-links/boost/xpressive/detail/core/peeker.hpp | 4
branches/fix-links/boost/xpressive/detail/dynamic/parser.hpp | 2
branches/fix-links/boost/xpressive/detail/static/transforms/as_quantifier.hpp | 10
branches/fix-links/boost/xpressive/detail/static/transforms/as_set.hpp | 2
branches/fix-links/boost/xpressive/proto/debug.hpp | 1
branches/fix-links/boost/xpressive/proto/deep_copy.hpp | 2
branches/fix-links/boost/xpressive/proto/eval.hpp | 6
branches/fix-links/boost/xpressive/proto/fusion.hpp | 28 +
branches/fix-links/boost/xpressive/proto/literal.hpp | 14
branches/fix-links/boost/xpressive/proto/make_expr.hpp | 31
branches/fix-links/boost/xpressive/proto/matches.hpp | 145 ++++++-
branches/fix-links/boost/xpressive/proto/ref.hpp | 2
branches/fix-links/boost/xpressive/proto/traits.hpp | 19
branches/fix-links/boost/xpressive/proto/transform/arg.hpp | 27 +
branches/fix-links/boost/xpressive/proto/transform/bind.hpp | 8
branches/fix-links/boost/xpressive/proto/transform/call.hpp | 17
branches/fix-links/boost/xpressive/proto/transform/fold.hpp | 16
branches/fix-links/boost/xpressive/proto/transform/fold_tree.hpp | 13
branches/fix-links/boost/xpressive/proto/transform/make.hpp | 13
branches/fix-links/boost/xpressive/proto/transform/pass_through.hpp | 5
branches/fix-links/boost/xpressive/proto/transform/when.hpp | 3
branches/fix-links/boost/xpressive/regex_actions.hpp | 12
branches/fix-links/boost/xpressive/regex_primitives.hpp | 2
branches/fix-links/libs/graph/test/csr_graph_test.cpp | 11
branches/fix-links/libs/lambda/doc/lambda.xml | 4
branches/fix-links/libs/libraries.htm | 6
branches/fix-links/libs/math/test/common_factor_test.cpp | 9
branches/fix-links/libs/multi_index/doc/compiler_specifics.html | 26
branches/fix-links/libs/preprocessor/doc/ref/seq_tail.html | 2
branches/fix-links/libs/ptr_container/doc/default.css | 2
branches/fix-links/libs/ptr_container/doc/intro.xml | 12
branches/fix-links/libs/ptr_container/doc/ptr_container.xml | 12
branches/fix-links/libs/ptr_container/test/Jamfile.v2 | 11
branches/fix-links/libs/range/doc/boost_range.html | 8
branches/fix-links/libs/range/doc/example.cpp | 10
branches/fix-links/libs/range/doc/examples.html | 9
branches/fix-links/libs/range/doc/faq.html | 11
branches/fix-links/libs/range/doc/headers.html | 9
branches/fix-links/libs/range/doc/history_ack.html | 9
branches/fix-links/libs/range/doc/intro.html | 9
branches/fix-links/libs/range/doc/portability.html | 11
branches/fix-links/libs/range/doc/range.html | 38 -
branches/fix-links/libs/range/doc/style.css | 11
branches/fix-links/libs/range/doc/style.html | 8
branches/fix-links/libs/range/doc/utility_class.html | 15
branches/fix-links/libs/range/test/partial_workaround.cpp | 8
branches/fix-links/libs/regex/performance/input.html | 3
branches/fix-links/libs/thread/test/test_mutex.cpp | 11
branches/fix-links/libs/type_traits/cxx_type_traits.htm | 3
branches/fix-links/libs/unordered/test/exception/assign_exception_tests.cpp | 8
branches/fix-links/libs/unordered/test/exception/swap_exception_tests.cpp | 12
branches/fix-links/libs/unordered/test/unordered/equivalent_keys_tests.cpp | 4
branches/fix-links/libs/wave/samples/cpp_tokens/slex_token.hpp | 9
branches/fix-links/libs/xpressive/proto/doc/Jamfile.v2 | 22
branches/fix-links/libs/xpressive/proto/doc/evaluation.qbk | 512 ++++++++++++++++++++++++++
branches/fix-links/libs/xpressive/proto/doc/installation.qbk | 6
branches/fix-links/libs/xpressive/proto/doc/proto.qbk | 65 +-
branches/fix-links/libs/xpressive/proto/doc/protodoc.xml | 761 ++++++++++++++++++++-------------------
branches/fix-links/libs/xpressive/proto/doc/transforms.qbk | 192 ++++++++++
branches/fix-links/libs/xpressive/proto/test/toy_spirit2.cpp | 79 ++-
branches/fix-links/libs/xpressive/test/test_symbols.cpp | 2
branches/fix-links/libs/xpressive/test/test_typeof2.cpp | 2
branches/fix-links/tools/bcp/scan_cvs_path.cpp | 6
branches/fix-links/tools/boostbook/xsl/navbar.xsl | 6
branches/fix-links/tools/build/v2/tools/darwin.jam | 12
branches/fix-links/tools/build/v2/tools/msvc.jam | 8
branches/fix-links/tools/regression/src/regression.py | 2
78 files changed, 1786 insertions(+), 642 deletions(-)
Modified: branches/fix-links/boost/config/compiler/sunpro_cc.hpp
==============================================================================
--- branches/fix-links/boost/config/compiler/sunpro_cc.hpp (original)
+++ branches/fix-links/boost/config/compiler/sunpro_cc.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -84,8 +84,8 @@
#error "Compiler not supported or configured - please reconfigure"
#endif
//
-// last known and checked version is 0x570:
-#if (__SUNPRO_CC > 0x580)
+// last known and checked version is 0x590:
+#if (__SUNPRO_CC > 0x590)
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
# endif
Modified: branches/fix-links/boost/function_types/detail/cv_traits.hpp
==============================================================================
--- branches/fix-links/boost/function_types/detail/cv_traits.hpp (original)
+++ branches/fix-links/boost/function_types/detail/cv_traits.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -12,7 +12,9 @@
#include <cstddef>
#include <boost/detail/workaround.hpp>
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ || BOOST_WORKAROUND(__BORLANDC__, <= 0x582) \
+ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
# include <boost/type_traits/remove_cv.hpp>
# include <boost/type_traits/remove_pointer.hpp>
# include <boost/type_traits/remove_reference.hpp>
@@ -25,7 +27,9 @@
namespace ft = boost::function_types;
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
+#if ! (defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ || BOOST_WORKAROUND(__BORLANDC__, <= 0x582) \
+ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)))
template<typename T> struct cv_traits
{ typedef non_cv tag; typedef T type; };
Modified: branches/fix-links/boost/graph/compressed_sparse_row_graph.hpp
==============================================================================
--- branches/fix-links/boost/graph/compressed_sparse_row_graph.hpp (original)
+++ branches/fix-links/boost/graph/compressed_sparse_row_graph.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -347,6 +347,7 @@
add_vertex(BOOST_CSR_GRAPH_TYPE& g) {
Vertex old_num_verts_plus_one = g.m_rowstart.size();
g.m_rowstart.push_back(EdgeIndex(0));
+ g.vertex_properties().resize(num_vertices(g));
return old_num_verts_plus_one - 1;
}
@@ -355,6 +356,7 @@
add_vertices(typename BOOST_CSR_GRAPH_TYPE::vertices_size_type count, BOOST_CSR_GRAPH_TYPE& g) {
Vertex old_num_verts_plus_one = g.m_rowstart.size();
g.m_rowstart.resize(old_num_verts_plus_one + count, EdgeIndex(0));
+ g.vertex_properties().resize(num_vertices(g));
return old_num_verts_plus_one - 1;
}
Modified: branches/fix-links/boost/graph/detail/indexed_properties.hpp
==============================================================================
--- branches/fix-links/boost/graph/detail/indexed_properties.hpp (original)
+++ branches/fix-links/boost/graph/detail/indexed_properties.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -49,6 +49,7 @@
// Initialize with n default-constructed property values
indexed_vertex_properties(std::size_t n) : m_vertex_properties(n) { }
+public:
// Resize the properties vector
void resize(std::size_t n)
{
@@ -92,6 +93,8 @@
// All operations do nothing.
indexed_vertex_properties() { }
indexed_vertex_properties(std::size_t) { }
+
+public:
void resize(std::size_t) { }
void reserve(std::size_t) { }
};
Modified: branches/fix-links/boost/range/iterator_range.hpp
==============================================================================
--- branches/fix-links/boost/range/iterator_range.hpp (original)
+++ branches/fix-links/boost/range/iterator_range.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -11,6 +11,11 @@
#ifndef BOOST_RANGE_ITERATOR_RANGE_HPP
#define BOOST_RANGE_ITERATOR_RANGE_HPP
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)
+ #pragma warning( push )
+ #pragma warning( disable : 4996 )
+#endif
+
// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
#include <boost/config.hpp> // Define __STL_CONFIG_H, if appropriate.
#ifndef BOOST_OLD_IOSTREAMS
@@ -38,10 +43,6 @@
#endif // _STLP_NO_IOSTREAMS
#include <cstddef>
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) || BOOST_WORKAROUND(BOOST_MSVC, == 1400)
- #pragma warning( disable : 4996 )
-#endif
-
/*! \file
Defines the \c iterator_class and related functions.
\c iterator_range is a simple wrapper of iterator pair idiom. It provides
@@ -639,5 +640,9 @@
#undef BOOST_OLD_IOSTREAMS
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)
+ #pragma warning( pop )
+#endif
+
#endif
Modified: branches/fix-links/boost/range/sub_range.hpp
==============================================================================
--- branches/fix-links/boost/range/sub_range.hpp (original)
+++ branches/fix-links/boost/range/sub_range.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -11,12 +11,12 @@
#ifndef BOOST_RANGE_SUB_RANGE_HPP
#define BOOST_RANGE_SUB_RANGE_HPP
-#include <boost/detail/workaround.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) || BOOST_WORKAROUND(BOOST_MSVC, == 1400)
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)
+ #pragma warning( push )
#pragma warning( disable : 4996 )
#endif
+#include <boost/detail/workaround.hpp>
#include <boost/range/config.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/value_type.hpp>
@@ -46,7 +46,7 @@
sub_range() : base()
{ }
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) || BOOST_WORKAROUND(BOOST_MSVC, == 1400)
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
sub_range( const sub_range& r )
: base( static_cast<const base&>( r ) )
{ }
@@ -163,5 +163,9 @@
} // namespace 'boost'
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)
+ #pragma warning( pop )
+#endif
+
#endif
Modified: branches/fix-links/boost/thread/win32/basic_recursive_mutex.hpp
==============================================================================
--- branches/fix-links/boost/thread/win32/basic_recursive_mutex.hpp (original)
+++ branches/fix-links/boost/thread/win32/basic_recursive_mutex.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -56,6 +56,12 @@
long const current_thread_id=win32::GetCurrentThreadId();
return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
}
+ template<typename Duration>
+ bool timed_lock(Duration const& timeout)
+ {
+ return timed_lock(get_system_time()+timeout);
+ }
+
long get_active_count()
{
return mutex.get_active_count();
Modified: branches/fix-links/boost/thread/win32/basic_timed_mutex.hpp
==============================================================================
--- branches/fix-links/boost/thread/win32/basic_timed_mutex.hpp (original)
+++ branches/fix-links/boost/thread/win32/basic_timed_mutex.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -104,6 +104,12 @@
return true;
}
+ template<typename Duration>
+ bool timed_lock(Duration const& timeout)
+ {
+ return timed_lock(get_system_time()+timeout);
+ }
+
long get_active_count()
{
return ::boost::detail::interlocked_read_acquire(&active_count);
Modified: branches/fix-links/boost/xpressive/detail/core/matcher/action_matcher.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/core/matcher/action_matcher.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/core/matcher/action_matcher.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -16,6 +16,7 @@
# pragma once
#endif
+#include <boost/config.hpp>
#include <boost/version.hpp>
#include <boost/ref.hpp>
#include <boost/assert.hpp>
@@ -39,6 +40,13 @@
# include <boost/fusion/include/pop_front.hpp>
#endif
+#if BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4510) // default constructor could not be generated
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
+#endif
+
namespace boost { namespace xpressive { namespace detail
{
@@ -474,4 +482,8 @@
}}}
+#if BOOST_MSVC
+#pragma warning(pop)
+#endif
+
#endif
Modified: branches/fix-links/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -16,6 +16,7 @@
#include <boost/assert.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
#include <boost/xpressive/detail/core/quant_style.hpp>
+#include <boost/xpressive/detail/utility/ignore_unused.hpp>
#include <boost/xpressive/detail/core/state.hpp>
namespace boost { namespace xpressive { namespace detail
@@ -95,6 +96,7 @@
bool is_word(Traits const &traits, char_type ch) const
{
+ detail::ignore_unused(traits);
return traits.isctype(traits.translate(ch), this->word_);
}
Modified: branches/fix-links/boost/xpressive/detail/core/matcher/attr_matcher.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/core/matcher/attr_matcher.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/core/matcher/attr_matcher.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -41,6 +41,8 @@
{
return this->traits_.translate(ch1);
}
+ private:
+ char_translate &operator =(char_translate const &);
};
///////////////////////////////////////////////////////////////////////////////
Modified: branches/fix-links/boost/xpressive/detail/core/peeker.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/core/peeker.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/core/peeker.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -61,6 +61,8 @@
hash_peek_bitset<char_type> &bset_;
Traits const &traits_;
+private:
+ char_sink &operator =(char_sink const &);
};
///////////////////////////////////////////////////////////////////////////////
@@ -257,6 +259,8 @@
}
private:
+ xpression_peeker(xpression_peeker const &);
+ xpression_peeker &operator =(xpression_peeker const &);
template<typename Traits>
Traits const &get_traits_() const
Modified: branches/fix-links/boost/xpressive/detail/dynamic/parser.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/dynamic/parser.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/dynamic/parser.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -21,6 +21,7 @@
#include <boost/xpressive/regex_constants.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
#include <boost/xpressive/detail/core/matchers.hpp>
+#include <boost/xpressive/detail/utility/ignore_unused.hpp>
#include <boost/xpressive/detail/dynamic/dynamic.hpp>
// The Regular Expression grammar, in pseudo BNF:
@@ -171,6 +172,7 @@
, Traits const &traits
)
{
+ detail::ignore_unused(traits);
if(0 != compound.posix_yes())
{
typename Traits::char_class_type mask = compound.posix_yes();
Modified: branches/fix-links/boost/xpressive/detail/static/transforms/as_quantifier.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/static/transforms/as_quantifier.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/static/transforms/as_quantifier.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -79,7 +79,7 @@
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &expr, State const &, Visitor &visitor) const
{
typedef result<void(Expr, State, Visitor)> result_;
typedef typename result_::arg_type arg_type;
@@ -115,7 +115,7 @@
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &expr, State const &, Visitor &visitor) const
{
// we're inserting a hidden mark ... so grab the next hidden mark number.
int mark_nbr = visitor.get_hidden_mark();
@@ -210,7 +210,7 @@
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &expr, State const &, Visitor &visitor) const
{
return typename result<void(Expr, State, Visitor)>::type(
Grammar()(expr, detail::alternate_end_xpression(), visitor)
@@ -236,7 +236,7 @@
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &expr, State const &, Visitor &visitor) const
{
int mark_number = proto::arg(proto::left(expr)).mark_number_;
return typename result<void(Expr, State, Visitor)>::type(
@@ -280,7 +280,7 @@
template<typename Expr, typename State, typename Visitor>
typename unary_expr<optional_tag<Greedy>, Expr>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &expr, State const &, Visitor &) const
{
typename unary_expr<optional_tag<Greedy>, Expr>::type that = {expr};
return that;
Modified: branches/fix-links/boost/xpressive/detail/static/transforms/as_set.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/detail/static/transforms/as_set.hpp (original)
+++ branches/fix-links/boost/xpressive/detail/static/transforms/as_set.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -119,6 +119,8 @@
}
private:
+ merge_charset &operator =(merge_charset const &);
+
template<typename Expr, typename Tag>
void call_(Expr const &expr, Tag) const
{
Modified: branches/fix-links/boost/xpressive/proto/debug.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/debug.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/debug.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -181,6 +181,7 @@
}
private:
+ display_expr &operator =(display_expr const &);
int depth_;
mutable bool first_;
std::ostream &sout_;
Modified: branches/fix-links/boost/xpressive/proto/deep_copy.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/deep_copy.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/deep_copy.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -86,7 +86,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
Modified: branches/fix-links/boost/xpressive/proto/eval.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/eval.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/eval.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -10,6 +10,7 @@
#define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
#include <boost/xpressive/proto/detail/prefix.hpp> // must be first include
+#include <boost/xpressive/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE
#include <boost/type_traits/remove_reference.hpp>
#include <boost/xpressive/proto/detail/suffix.hpp> // must be last include
@@ -42,7 +43,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr, typename Context>
struct result<This(Expr, Context)>
@@ -60,8 +61,7 @@
/// \param The Proto expression to evaluate
/// \param The context in which the expression should be
/// evaluated.
- /// \note This function is equivalent to
- /// <tt>typename Context::template eval<Expr>()(expr, context)</tt>.
+ /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
template<typename Expr, typename Context>
typename proto::result_of::eval<Expr, Context>::type
operator ()(Expr &expr, Context &context) const
Modified: branches/fix-links/boost/xpressive/proto/fusion.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/fusion.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/fusion.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -10,6 +10,7 @@
#define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006
#include <boost/xpressive/proto/detail/prefix.hpp>
+#include <boost/config.hpp>
#include <boost/version.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/long.hpp>
@@ -43,6 +44,13 @@
#include <boost/xpressive/proto/eval.hpp>
#include <boost/xpressive/proto/detail/suffix.hpp>
+#if BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4510) // default constructor could not be generated
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
+#endif
+
namespace boost { namespace proto
{
@@ -88,7 +96,7 @@
struct as_element
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -128,7 +136,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -158,7 +166,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -189,7 +197,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -214,16 +222,22 @@
/// \sa boost::proto::functional::flatten
functional::flatten const flatten = {};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<functional::flatten>
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<functional::pop_front>
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<functional::reverse>
: mpl::true_
@@ -239,7 +253,7 @@
{}
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -632,4 +646,8 @@
#undef UNREF
+#if BOOST_MSVC
+#pragma warning(pop)
+#endif
+
#endif
Modified: branches/fix-links/boost/xpressive/proto/literal.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/literal.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/literal.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -40,6 +40,10 @@
typedef extends<terminal_type, literal<T, Domain>, Domain> base_type;
public:
+ typedef typename proto::result_of::arg<terminal_type>::type value_type;
+ typedef typename proto::result_of::arg<terminal_type>::reference reference;
+ typedef typename proto::result_of::arg<terminal_type>::const_reference const_reference;
+
template<typename U>
literal(U &u)
: base_type(terminal_type::make(u))
@@ -56,6 +60,16 @@
{}
using base_type::operator =;
+
+ reference get()
+ {
+ return proto::arg(*this);
+ }
+
+ const_reference get() const
+ {
+ return proto::arg(*this);
+ }
};
}
Modified: branches/fix-links/boost/xpressive/proto/make_expr.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/make_expr.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/make_expr.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -351,10 +351,14 @@
struct protoify_
{
typedef
+ typename boost::unwrap_reference<T>::type
+ unref_type;
+
+ typedef
typename mpl::eval_if<
boost::is_reference_wrapper<T>
- , proto::result_of::as_arg<typename boost::unwrap_reference<T>::type, Domain>
- , proto::result_of::as_expr<T, Domain>
+ , proto::result_of::as_arg<unref_type, Domain>
+ , proto::result_of::as_expr<unref_type, Domain>
>::type
type;
@@ -364,7 +368,7 @@
is_reference_wrapper<T>
, functional::as_arg<Domain>
, functional::as_expr<Domain>
- >::type()(static_cast<typename boost::unwrap_reference<T>::type &>(t));
+ >::type()(static_cast<unref_type &>(t));
}
};
@@ -372,17 +376,16 @@
struct protoify_<T &, Domain>
{
typedef
- typename proto::result_of::as_arg<
- typename boost::unwrap_reference<T>::type
- , Domain
- >::type
+ typename boost::unwrap_reference<T>::type
+ unref_type;
+
+ typedef
+ typename proto::result_of::as_arg<unref_type, Domain>::type
type;
static type call(T &t)
{
- return functional::as_arg<Domain>()(
- static_cast<typename boost::unwrap_reference<T>::type &>(t)
- );
+ return functional::as_arg<Domain>()(static_cast<unref_type &>(t));
}
};
@@ -563,7 +566,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename A0>
struct result<This(A0)>
@@ -645,7 +648,7 @@
BOOST_PROTO_CALLABLE()
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Sequence>
struct result<This(Sequence)>
@@ -757,11 +760,15 @@
#include BOOST_PP_ITERATE()
+ /// INTERNAL ONLY
+ ///
template<typename Tag, typename Domain>
struct is_callable<functional::make_expr<Tag, Domain> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<typename Tag, typename Domain>
struct is_callable<functional::unpack_expr<Tag, Domain> >
: mpl::true_
Modified: branches/fix-links/boost/xpressive/proto/matches.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/matches.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/matches.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -392,9 +392,76 @@
namespace result_of
{
+ /// \brief A Boolean metafunction that evaluates whether a given
+ /// expression type matches a grammar.
+ ///
+ /// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from
+ /// \c mpl::true_ if <tt>Expr::proto_base_expr</tt> matches
+ /// <tt>Grammar::proto_base_expr</tt>, and from \c mpl::false_
+ /// otherwise.
+ ///
+ /// Non-terminal expressions are matched against a grammar
+ /// according to the following rules:
+ ///
+ /// \li The wildcard pattern, \c _, matches any expression.
+ /// \li An expression <tt>expr\<AT, argsN\<A0,A1,...An\> \></tt>
+ /// matches a grammar <tt>expr\<BT, argsN\<B0,B1,...Bn\> \></tt>
+ /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for
+ /// each \c x in <tt>[0,n)</tt>.
+ /// \li An expression <tt>expr\<AT, argsN\<A0,...An,U0,...Um\> \></tt>
+ /// matches a grammar <tt>expr\<BT, argsM\<B0,...Bn,vararg\<V\> \> \></tt>
+ /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx
+ /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V
+ /// for each \c x in <tt>[0,m)</tt>.
+ /// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E
+ /// matches some \c Bx for \c x in <tt>[0,n)</tt>.
+ /// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
+ /// matches all \c Bx for \c x in <tt>[0,n)</tt>.
+ /// \li An expression \c E matches <tt>if_\<T\></tt> if
+ /// <tt>when\<_,T\>::result\<void(E,int,int)\>::type::value</tt>
+ /// is \c true.
+ /// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if
+ /// <tt>when\<_,T\>::result\<void(E,int,int)\>::type::value</tt>
+ /// is \c true and \E matches \c U; or, if
+ /// <tt>when\<_,T\>::result\<void(E,int,int)\>::type::value</tt>
+ /// is \c false and \E matches \c V.
+ /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does
+ /// not match \c T.
+ /// \li An expression \c E matches <tt>switch_\<C\></tt> if
+ /// \c E matches <tt>C::case_\<E::proto_tag\></tt>.
+ ///
+ /// A terminal expression <tt>expr\<tag::terminal,args0\<A\> \></tt> matches
+ /// a grammar <tt>expr\<BT,args0\<B\> \></tt> if \c BT is \c _ or
+ /// \c tag::terminal and one of the following is true:
+ ///
+ /// \li \c B is the wildcard pattern, \c _
+ /// \li \c A is \c B
+ /// \li \c A is <tt>B &</tt>
+ /// \li \c A is <tt>B const &</tt>
+ /// \li \c B is <tt>exact\<A\></tt>
+ /// \li \c B is <tt>convertible_to\<X\></tt> and
+ /// <tt>is_convertible\<A,X\>::value</tt> is \c true.
+ /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
+ /// \c B is <tt>X[proto::N]</tt>.
+ /// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>.
+ /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
+ /// \c B is <tt>X*</tt>.
+ /// \li \c B lambda-matches \c A (see below).
+ ///
+ /// A type \c B lambda-matches \c A if one of the following is true:
+ ///
+ /// \li \c B is \c A
+ /// \li \c B is the wildcard pattern, \c _
+ /// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is
+ /// <tt>T\<A0,A1,...An\></tt> and for each \c x in
+ /// <tt>[0,n)</tt>, \c Ax and \c Bx are types
+ /// such that \c Ax lambda-matches \c Bx
template<typename Expr, typename Grammar>
struct matches
- : detail::matches_<typename Expr::proto_base_expr, typename Grammar::proto_base_expr>
+ : detail::matches_<
+ typename Expr::proto_base_expr
+ , typename Grammar::proto_base_expr
+ >
{};
}
@@ -404,7 +471,8 @@
{
typedef _ proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -412,6 +480,8 @@
typedef Expr type;
};
+ /// \param expr An expression
+ /// \return expr
template<typename Expr, typename State, typename Visitor>
Expr const &operator ()(Expr const &expr, State const &, Visitor &) const
{
@@ -428,7 +498,8 @@
{
typedef not_ proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -436,6 +507,8 @@
typedef Expr type;
};
+ /// \param expr An expression
+ /// \return expr
template<typename Expr, typename State, typename Visitor>
Expr const &operator ()(Expr const &expr, State const &, Visitor &) const
{
@@ -449,35 +522,40 @@
{
typedef if_ proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
{
typedef
+ typename when<_, If>::template result<void(Expr, State, Visitor)>::type
+ condition;
+
+ typedef
typename mpl::if_<
- typename when<_, If>::template result<void(Expr, State, Visitor)>::type
+ condition
, when<_, Then>
, when<_, Else>
>::type
- branch;
+ which;
- typedef typename branch::template result<void(Expr, State, Visitor)>::type type;
+ typedef typename which::template result<void(Expr, State, Visitor)>::type type;
};
+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
{
typedef
- typename mpl::if_<
- typename when<_, If>::template result<void(Expr, State, Visitor)>::type
- , when<_, Then>
- , when<_, Else>
- >::type
- branch;
+ typename result<void(Expr, State, Visitor)>::which
+ which;
- return branch()(expr, state, visitor);
+ return which()(expr, state, visitor);
}
};
@@ -487,7 +565,8 @@
{
typedef or_ proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -496,6 +575,10 @@
typedef typename which::template result<void(Expr, State, Visitor)>::type type;
};
+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
@@ -511,7 +594,8 @@
{
typedef and_ proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -520,6 +604,10 @@
typedef typename which::template result<void(Expr, State, Visitor)>::type type;
};
+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
@@ -535,21 +623,26 @@
{
typedef switch_ proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
{
- typedef typename Cases::template case_<typename Expr::proto_tag> impl;
- typedef typename impl::template result<void(Expr, State, Visitor)>::type type;
+ typedef typename Cases::template case_<typename Expr::proto_tag> which;
+ typedef typename which::template result<void(Expr, State, Visitor)>::type type;
};
+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
operator ()(Expr const &expr, State const &state, Visitor &visitor) const
{
- typedef typename Cases::template case_<typename Expr::proto_tag> impl;
- return impl()(expr, state, visitor);
+ typedef typename Cases::template case_<typename Expr::proto_tag> which;
+ return which()(expr, state, visitor);
}
};
@@ -569,26 +662,36 @@
};
}
+ /// INTERNAL ONLY
+ ///
template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)>
struct is_callable<or_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)>
struct is_callable<and_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<typename Grammar>
struct is_callable<not_<Grammar> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<typename If, typename Then, typename Else>
struct is_callable<if_<If, Then, Else> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<typename Grammar>
struct is_callable<vararg<Grammar> >
: mpl::true_
Modified: branches/fix-links/boost/xpressive/proto/ref.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/ref.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/ref.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -136,7 +136,7 @@
struct unref
{
template<typename T>
- struct result {};
+ struct result;
template<typename This, typename T>
struct result<This(T)>
Modified: branches/fix-links/boost/xpressive/proto/traits.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/traits.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/traits.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -83,11 +83,15 @@
: proto::detail::is_callable_<T>
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<proto::_>
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<proto::callable>
: mpl::false_
@@ -243,7 +247,8 @@
template<typename T>
struct terminal
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -401,7 +406,7 @@
struct as_expr
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename T>
struct result<This(T)>
@@ -443,7 +448,7 @@
struct as_arg
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename T>
struct result<This(T)>
@@ -469,7 +474,7 @@
struct arg_c
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -493,7 +498,7 @@
struct arg
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -516,7 +521,7 @@
struct left
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
@@ -539,7 +544,7 @@
struct right
{
template<typename Sig>
- struct result {};
+ struct result;
template<typename This, typename Expr>
struct result<This(Expr)>
Modified: branches/fix-links/boost/xpressive/proto/transform/arg.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/arg.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/arg.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -22,7 +22,8 @@
struct expr : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -40,7 +41,8 @@
struct state : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -58,7 +60,8 @@
struct visitor : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -77,7 +80,8 @@
template<int I>
struct arg_c : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -95,7 +99,8 @@
struct _ref : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename T>
struct result<This(T)>
@@ -130,31 +135,43 @@
: transform::arg_c<I>
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<transform::expr>
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<transform::state>
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<transform::visitor>
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<int I>
struct is_callable<transform::arg_c<I> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<int I>
struct is_callable<_arg_c<I> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<>
struct is_callable<transform::_ref>
: mpl::true_
Modified: branches/fix-links/boost/xpressive/proto/transform/bind.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/bind.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/bind.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -27,7 +27,8 @@
template<typename Fun>
struct bind : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -49,6 +50,8 @@
}
+ /// INTERNAL ONLY
+ ///
template<typename Fun>
struct is_callable<transform::bind<Fun> >
: mpl::true_
@@ -65,7 +68,8 @@
template<typename Return BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
struct bind<Return(BOOST_PP_ENUM_PARAMS(N, A))> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
Modified: branches/fix-links/boost/xpressive/proto/transform/call.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/call.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/call.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -186,7 +186,8 @@
template<typename Fun>
struct call<Fun()> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -221,7 +222,8 @@
template<typename Fun, typename Arg0>
struct call<Fun(Arg0)> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -260,7 +262,8 @@
template<typename Fun, typename Arg0, typename Arg1>
struct call<Fun(Arg0, Arg1)> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -299,7 +302,8 @@
template<typename Fun, typename Arg0, typename Arg1, typename Arg2>
struct call<Fun(Arg0, Arg1, Arg2)> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -334,6 +338,8 @@
#endif
}
+ /// INTERNAL ONLY
+ ///
template<typename Fun>
struct is_callable<transform::call<Fun> >
: mpl::true_
@@ -350,7 +356,8 @@
template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
Modified: branches/fix-links/boost/xpressive/proto/transform/fold.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/fold.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/fold.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -43,7 +43,8 @@
: v_(v)
{}
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State>
struct result<This(Expr, State)>
@@ -161,7 +162,8 @@
template<typename Sequence, typename State0, typename Fun>
struct fold : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -206,7 +208,8 @@
template<typename State0, typename Fun>
struct fold<_, State0, Fun> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -250,7 +253,8 @@
template<typename State0, typename Fun>
struct reverse_fold<_, State0, Fun> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -287,11 +291,15 @@
};
}
+ /// INTERNAL ONLY
+ ///
template<typename Sequence, typename State, typename Fun>
struct is_callable<transform::fold<Sequence, State, Fun> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<typename Sequence, typename State, typename Fun>
struct is_callable<transform::reverse_fold<Sequence, State, Fun> >
: mpl::true_
Modified: branches/fix-links/boost/xpressive/proto/transform/fold_tree.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/fold_tree.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/fold_tree.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -26,7 +26,8 @@
template<typename Tag>
struct is_tag : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -49,7 +50,8 @@
struct fold_tree
: proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -81,7 +83,8 @@
struct reverse_fold_tree
: proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -110,11 +113,15 @@
};
}
+ /// INTERNAL ONLY
+ ///
template<typename Sequence, typename State0, typename Fun>
struct is_callable<transform::fold_tree<Sequence, State0, Fun> >
: mpl::true_
{};
+ /// INTERNAL ONLY
+ ///
template<typename Sequence, typename State0, typename Fun>
struct is_callable<transform::reverse_fold_tree<Sequence, State0, Fun> >
: mpl::true_
Modified: branches/fix-links/boost/xpressive/proto/transform/make.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/make.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/make.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -168,7 +168,8 @@
template<typename Fun>
struct make : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -178,7 +179,7 @@
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &, State const &, Visitor &) const
{
typedef typename result<void(Expr, State, Visitor)>::type result_type;
return result_type();
@@ -189,6 +190,8 @@
#include BOOST_PP_ITERATE()
}
+ /// INTERNAL ONLY
+ ///
template<typename Fun>
struct is_callable<transform::make<Fun> >
: mpl::true_
@@ -273,7 +276,8 @@
template<typename Return BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
struct make<Return(BOOST_PP_ENUM_PARAMS(N, A))> : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -300,7 +304,8 @@
struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
: proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
Modified: branches/fix-links/boost/xpressive/proto/transform/pass_through.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/pass_through.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/pass_through.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -66,7 +66,8 @@
template<typename Grammar>
struct pass_through : proto::callable
{
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
@@ -102,6 +103,8 @@
} // namespace transform
+ /// INTERNAL ONLY
+ ///
template<typename Grammar>
struct is_callable<transform::pass_through<Grammar> >
: mpl::true_
Modified: branches/fix-links/boost/xpressive/proto/transform/when.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/proto/transform/when.hpp (original)
+++ branches/fix-links/boost/xpressive/proto/transform/when.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -60,7 +60,8 @@
{
typedef typename Grammar::proto_base_expr proto_base_expr;
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;
template<typename This, typename Expr, typename State, typename Visitor>
struct result<This(Expr, State, Visitor)>
Modified: branches/fix-links/boost/xpressive/regex_actions.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/regex_actions.hpp (original)
+++ branches/fix-links/boost/xpressive/regex_actions.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -14,6 +14,7 @@
# pragma once
#endif
+#include <boost/config.hpp>
#include <boost/ref.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
@@ -52,6 +53,13 @@
///
#define UNCVREF(x) typename remove_cv<typename remove_reference<x>::type>::type
+#if BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4510) // default constructor could not be generated
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
+#endif
+
namespace boost { namespace xpressive
{
@@ -818,4 +826,8 @@
#undef UNREF
#undef UNCVREF
+#if BOOST_MSVC
+#pragma warning(pop)
+#endif
+
#endif // BOOST_XPRESSIVE_ACTIONS_HPP_EAN_03_22_2007
Modified: branches/fix-links/boost/xpressive/regex_primitives.hpp
==============================================================================
--- branches/fix-links/boost/xpressive/regex_primitives.hpp (original)
+++ branches/fix-links/boost/xpressive/regex_primitives.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -136,7 +136,7 @@
template<typename Expr, typename State, typename Visitor>
typename result<void(Expr, State, Visitor)>::type
- operator ()(Expr const &expr, State const &state, Visitor &visitor) const
+ operator ()(Expr const &expr, State const &state, Visitor &) const
{
typedef typename result<void(Expr, State, Visitor)>::type type;
type that = {{{state}}, expr};
Deleted: branches/fix-links/doc/html/boost_math.html
==============================================================================
--- branches/fix-links/doc/html/boost_math.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,19 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
- <head>
- <!-- Copyright (C) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt) -->
- <title>Redirect to generated documentation</title>
- <meta http-equiv="refresh" content="0; URL=http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_math.html">
- </head>
- <body>
- Automatic redirection failed, please go to
- http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_math.html
- </body>
-</html>
-
-
-
Deleted: branches/fix-links/doc/html/boost_typetraits.html
==============================================================================
--- branches/fix-links/doc/html/boost_typetraits.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,17 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
- <head>
- <!-- Copyright (C) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt) -->
- <title>Redirect to generated documentation</title>
- <meta http-equiv="refresh" content="0; URL=http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_typetraits.html">
- </head>
- <body>
- Automatic redirection failed, please go to
- http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_typetraits.html
- </body>
-</html>
-
Deleted: branches/fix-links/libs/bimap/doc/html/boost_bimap/the_tutorial/hooking_information.html
==============================================================================
--- branches/fix-links/libs/bimap/doc/html/boost_bimap/the_tutorial/hooking_information.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,221 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Hooking
- Information</title>
-<link rel="stylesheet" href="../../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.70.1">
-<link rel="start" href="../../index.html" title="Chapter 1. Boost.Bimap">
-<link rel="up" href="../the_tutorial.html" title="The tutorial">
-<link rel="prev" href="unconstrained_sets.html" title="Unconstrained
- Sets">
-<link rel="next" href="complete_instantiation_scheme.html" title="Complete
- instantiation scheme">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="unconstrained_sets.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../the_tutorial.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="complete_instantiation_scheme.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_bimap.the_tutorial.hooking_information"></a><a href="hooking_information.html" title="Hooking
- Information">Hooking
- Information</a>
-</h3></div></div></div>
-<p>
- Bidirectional maps may have associated information about each relation. Suppose
- we want to represent a books and author bidirectional map.
- </p>
-<p>
- </p>
-<p>
-
-</p>
-<pre class="programlisting">
-<span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special"><</span>
-
- <span class="identifier">multiset_of</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">>,</span> <span class="comment">// author
-</span> <span class="identifier">set_of</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">></span> <span class="comment">// book name
-</span>
-<span class="special">></span> <span class="identifier">bm_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">book</span><span class="special">;</span>
-
-<span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
-
-<span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">book</span><span class="special">(</span> <span class="string">"Bjarne Stroustrup"</span> <span class="special">,</span> <span class="string">"The C++ Programming Language"</span> <span class="special">)</span> <span class="special">);</span>
-<span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">book</span><span class="special">(</span> <span class="string">"Scott Meyers"</span> <span class="special">,</span> <span class="string">"Effective C++"</span> <span class="special">)</span> <span class="special">);</span>
-<span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">book</span><span class="special">(</span> <span class="string">"Andrei Alexandrescu"</span> <span class="special">,</span> <span class="string">"Modern C++ Design"</span> <span class="special">)</span> <span class="special">);</span>
-
-<span class="comment">// Print the author of Modern C++
-</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span> <span class="string">"Modern C++ Design"</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- </p>
-<p>
- </p>
-<div class="calloutlist"><table border="0" summary="Callout list"></table></div>
-<p>
- </p>
-<p>
- </p>
-<p>
- Suppose now that we want to store abstract of each book. We have two options:
- </p>
-<div class="orderedlist"><ol type="1">
-<li>
- Books name are unique identifiers, so we can create a separate <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span> <span class="identifier">string</span><span class="special">,</span> <span class="identifier">string</span> <span class="special">></span></code>
- that relates books names with abstracts.
- </li>
-<li>
- We can use Boost.MultiIndex for the new beast.
- </li>
-</ol></div>
-<p>
- Option 1 is the wrong approach, if we go this path we lost what bimap has
- won us. We now have to maintain the logic of two interdependent containers,
- there is an extra string stored for each book name, and the performance will
- be worse. This is far away from being a good solution.
- </p>
-<p>
- Option 2 is correct. We start thinking books as entries in a table. So it
- makes sense to start using Boost.MultiIndex. We can then add the year of
- publication, the price, etc... and we can index this new items too. So Boost.MultiIndex
- is a sound solution for our problem.
- </p>
-<p>
- The thing is that there are cases where we want to maintain bimap semantics
- (use <code class="computeroutput"><span class="identifier">at</span><span class="special">()</span></code>
- to find an author given a book name and the other way around) and add information
- about the relations that we are sure we will not want to index later (like
- the abstracts). Option 1 is not possible, option 2 neither.
- </p>
-<p>
- Boost.Bimap provides support for this kind of situations by means of information
- hooking. You can pass an extra parameter to a bimap with the type <code class="computeroutput"><span class="identifier">info_hook</span><span class="special"><</span>
- <span class="identifier">InfoType</span> <span class="special">></span></code>
- and an <code class="computeroutput"><span class="identifier">info</span></code> member of type
- <code class="computeroutput"><span class="identifier">InfoType</span></code> will appear in the
- relation and bimap pairs.
- </p>
-<p>
- Relations and bimap pairs constructors can take an extra argument. If only
- two arguments are used, the information will be initialized with their default
- constructor.
- </p>
-<p>
- </p>
-<p>
-
-</p>
-<pre class="programlisting">
-<span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special"><</span>
-
- <span class="identifier">multiset_of</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">>,</span> <span class="comment">// author
-</span> <span class="identifier">set_of</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">>,</span> <span class="comment">// book name
-</span>
- <span class="identifier">with_info</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">></span> <span class="comment">// abstract
-</span>
-<span class="special">></span> <span class="identifier">bm_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">book</span><span class="special">;</span>
-
-<span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
-
-<span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span>
-
- <span class="identifier">book</span><span class="special">(</span> <span class="string">"Bjarne Stroustrup"</span> <span class="special">,</span> <span class="string">"The C++ Programming Language"</span><span class="special">,</span>
-
- <span class="string">"For C++ old-timers, the first edition of this book is"</span>
- <span class="string">"the one that started it all—the font of our knowledge."</span> <span class="special">)</span>
-<span class="special">);</span>
-
-
-<span class="comment">// Print the abstract of the bible
-</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="string">"The C++ Programming Language"</span><span class="special">);</span>
-
-<span class="comment">// Print the abstract of this book
-</span><span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">left_iterator</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="string">"Bjarne Stroustrup"</span><span class="special">);</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">i</span><span class="special">-></span><span class="identifier">info</span><span class="special">;</span>
-</pre>
-<p>
- </p>
-<p>
- </p>
-<p>
- </p>
-<div class="calloutlist"><table border="0" summary="Callout list"></table></div>
-<p>
- </p>
-<p>
- </p>
-<p>
- Contrary to the two key types, the information will be mutable using iterators.
- </p>
-<p>
- </p>
-<p>
-
-</p>
-<pre class="programlisting">
-<span class="identifier">i</span><span class="special">-></span><span class="identifier">info</span> <span class="special">+=</span> <span class="string">"More details about this book"</span><span class="special">;</span>
-</pre>
-<p>
- </p>
-<p>
- </p>
-<p>
- </p>
-<div class="calloutlist"><table border="0" summary="Callout list"></table></div>
-<p>
- </p>
-<p>
- </p>
-<p>
- A new function is included in <span class="emphasis"><em>unique</em></span> map views: <code class="computeroutput"><span class="identifier">info_at</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>, that
- mimics the standard <code class="computeroutput"><span class="identifier">at</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code> function
- but returned the associated information instead of the data.
- </p>
-<p>
- </p>
-<p>
-
-</p>
-<pre class="programlisting">
-<span class="comment">// Print the new abstract
-</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">info_at</span><span class="special">(</span><span class="string">"The C++ Programming Language"</span><span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- </p>
-<p>
- </p>
-<div class="calloutlist"><table border="0" summary="Callout list"></table></div>
-<p>
- </p>
-<p>
- </p>
-<p>
- Go to source code
- </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><small>Copyright © 2006 -2007 Matias Capeletto</small></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="unconstrained_sets.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../the_tutorial.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="complete_instantiation_scheme.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
Modified: branches/fix-links/libs/graph/test/csr_graph_test.cpp
==============================================================================
--- branches/fix-links/libs/graph/test/csr_graph_test.cpp (original)
+++ branches/fix-links/libs/graph/test/csr_graph_test.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -38,7 +38,13 @@
typedef boost::adjacency_list<> GraphT;
typedef boost::erdos_renyi_iterator<boost::minstd_rand, GraphT> ERGen;
-typedef boost::compressed_sparse_row_graph<> CSRGraphT;
+struct VertexData
+{
+ int index;
+};
+
+typedef boost::compressed_sparse_row_graph<boost::directedS, VertexData>
+ CSRGraphT;
template <class G1, class VI1, class G2, class VI2, class IsomorphismMap>
void assert_graphs_equal(const G1& g1, const VI1& vi1,
@@ -191,6 +197,9 @@
CSRGraphT g4;
BOOST_CHECK(num_vertices(g4) == 0);
std::size_t first_vert = add_vertices(num_vertices(g3), g4);
+ BGL_FORALL_VERTICES(v, g4, CSRGraphT)
+ g4[v].index = v;
+
BOOST_CHECK(first_vert == 0);
BOOST_CHECK(num_vertices(g4) == num_vertices(g3));
CSRGraphT::edge_iterator ei, ei_end;
Modified: branches/fix-links/libs/lambda/doc/lambda.xml
==============================================================================
--- branches/fix-links/libs/lambda/doc/lambda.xml (original)
+++ branches/fix-links/libs/lambda/doc/lambda.xml 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -3191,7 +3191,7 @@
-<appendix>
+<section>
<title>Rationale for some of the design decisions</title>
<section id="lambda.why_weak_arity">
@@ -3256,7 +3256,7 @@
</section>
-</appendix>
+</section>
Modified: branches/fix-links/libs/libraries.htm
==============================================================================
--- branches/fix-links/libs/libraries.htm (original)
+++ branches/fix-links/libs/libraries.htm 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -98,6 +98,8 @@
<li>call_traits -
Defines types for passing parameters, from John Maddock,
Howard Hinnant, et al.</li>
+ <li>circular_buffer - STL compliant
+ container also known as ring or cyclic buffer, from Jan Gaspar.</li>
<li>compatibility - Help for
non-conforming standard libraries, from Ralf Grosse-Kunstleve and Jens
Maurer.</li>
@@ -700,7 +702,7 @@
<p>Revised
<!--webbot bot="Timestamp" s-type="EDITED"
-s-format="%d %b %Y" startspan -->01 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15262" --></p>
+s-format="%d %b %Y" startspan -->05 Feb 2008<!--webbot bot="Timestamp" endspan i-checksum="14410" --></p>
<p>? Copyright Beman Dawes 2000-2004</p>
<p>Distributed under the Boost Software License, Version 1.0.
@@ -709,4 +711,4 @@
</p>
</body>
-</html>
+</html>
\ No newline at end of file
Modified: branches/fix-links/libs/math/test/common_factor_test.cpp
==============================================================================
--- branches/fix-links/libs/math/test/common_factor_test.cpp (original)
+++ branches/fix-links/libs/math/test/common_factor_test.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -129,6 +129,7 @@
} // namespace
+#define BOOST_NO_MACRO_EXPAND /**/
// Specialize numeric_limits for _some_ of our types
namespace std
@@ -143,8 +144,8 @@
public:
BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
- static MyInt1 min() throw() { return limits_type::min(); }
- static MyInt1 max() throw() { return limits_type::max(); }
+ static MyInt1 min BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::min)(); }
+ static MyInt1 max BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::max)(); }
BOOST_STATIC_CONSTANT(int, digits = limits_type::digits);
BOOST_STATIC_CONSTANT(int, digits10 = limits_type::digits10);
@@ -190,8 +191,8 @@
public:
BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
- static MyUnsigned1 min() throw() { return limits_type::min(); }
- static MyUnsigned1 max() throw() { return limits_type::max(); }
+ static MyUnsigned1 min BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::min)(); }
+ static MyUnsigned1 max BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::max)(); }
BOOST_STATIC_CONSTANT(int, digits = limits_type::digits);
BOOST_STATIC_CONSTANT(int, digits10 = limits_type::digits10);
Modified: branches/fix-links/libs/multi_index/doc/compiler_specifics.html
==============================================================================
--- branches/fix-links/libs/multi_index/doc/compiler_specifics.html (original)
+++ branches/fix-links/libs/multi_index/doc/compiler_specifics.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -50,6 +50,7 @@
<li>IBM VisualAge C++ V6.0 for AIX</li>
<li>IBM VisualAge C++ V9.0 for AIX</li>
<li>Intel C++ Compiler for Linux 8.1 and later</li>
+ <li>Intel C++ Compiler for Mac OS 9.1 and later</li>
<li>Intel C++ Compiler for Windows 32-bit 7.0/7.1</li>
<li>Intel C++ Compiler for Windows 32-bit 8.0 and later</li>
<li>Intel C++ Compiler for Windows 64-bit 10.0</li>
@@ -137,12 +138,13 @@
<li>GCC 3.4.3 under Linux x86-64,</li>
<li>GCC 3.4.4 under Linux, (cygming special) under Cygwin 1.5.22,</li>
<li>GCC 3.4.5 (mingw special) under Win32,</li>
- <li>GCC 3.4.6 under Linux x86-64,</li>
- <li>GCC 4.0.1 under Linux x86-64, (Apple builds 5363 and 5367) under Mac OS,</li>
+ <li>GCC 3.4.6 under Linux x86-64 and Solaris,</li>
+ <li>GCC 4.0.1 under Linux x86-64, (Apple builds 5363, 5367 and 5465) under Mac OS,</li>
<li>GCC 4.1.1 under Linux x86-64,</li>
<li>GCC 4.1.2 (OpenPKG-CURRENT) under Solaris,</li>
<li>GCC 4.2.1 under HP-UX IA64 and Linux x86-64, (mingw32-2) under Win32,</li>
- <li>GCC 4.2.2 under Linux.</li>
+ <li>GCC 4.2.2 under Linux and Linux x86-64,</li>
+ <li>GCC 4.3.0 20080206 (experimental) under Linux.</li>
</ul>
Boost.MultiIndex does not work with versions 3.1 and prior of GCC.
</p>
@@ -242,7 +244,14 @@
<p>
No problems have been detected with this compiler.
-Tested from version 8.1 to 9.1.
+Tested from version 8.1 to 10.1.
+</p>
+
+<h2><a name="intel_91_mac">Intel C++ Compiler for Mac OS 9.1 and later</a></h2>
+
+<p>
+No problems have been detected with this compiler.
+Last tested for versions 9.1 and 10.0.
</p>
<h2><a name="intel_7x_win">Intel C++ Compiler for Windows 32-bit 7.0/7.1</a></h2>
@@ -444,7 +453,7 @@
other unrelated libraries, like the
<a href="../../../libs/graph/doc/table_of_contents.html">Boost Graph Library</a>,
<a href="../../../libs/multi_array/doc/index.html">Boost.MultiArray</a>,
-Boost.Regex,
+Boost.Regex,
<a href="http://www.cgal.org/">CGAL</a> and
<a href="http://www.mysql.com/downloads/api-mysql++.html">MySQL++</a>.
The error is triggered, though not in a systematic manner, by the use
@@ -469,7 +478,7 @@
<p>
The second workaround has not been confirmed by the author, but it is given
on the Internet in connection with this error appearing in other libraries.
-Replace line 84 of <code><xlocnum></code>
+Replace line 84 of <code><xlocnum></code>
<blockquote><pre>
<span class=preprocessor>#define</span> <span class=identifier>_VIRTUAL</span> <span class=keyword>virtual</span>
@@ -675,7 +684,6 @@
<p>
No problems have been detected with this compiler.
-The Beta 2 version of this product was used for the testing.
</p>
<h2><a name="sun_10">Sun Studio 10 for Solaris and later</a></h2>
@@ -1113,9 +1121,9 @@
<br>
-<p>Revised November 6th 2007</p>
+<p>Revised February 7th 2008</p>
-<p>© Copyright 2003-2007 Joaquín M López Muñoz.
+<p>© Copyright 2003-2008 Joaquín M López Muñoz.
Distributed under the Boost Software
License, Version 1.0. (See accompanying file <a href="../../../LICENSE_1_0.txt">
LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
Modified: branches/fix-links/libs/preprocessor/doc/ref/seq_tail.html
==============================================================================
--- branches/fix-links/libs/preprocessor/doc/ref/seq_tail.html (original)
+++ branches/fix-links/libs/preprocessor/doc/ref/seq_tail.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -5,7 +5,7 @@
</head>
<body>
<div style="margin-left: 0px;">
- The <b>BOOST_PP_SEQ_HEAD</b> macro expands to all but the first element of a <i>seq</i>.
+ The <b>BOOST_PP_SEQ_TAIL</b> macro expands to all but the first element of a <i>seq</i>.
</div>
<h4>
Usage
Modified: branches/fix-links/libs/ptr_container/doc/default.css
==============================================================================
--- branches/fix-links/libs/ptr_container/doc/default.css (original)
+++ branches/fix-links/libs/ptr_container/doc/default.css 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -1,4 +1,6 @@
/*
+boostinspect:nolicense
+
:Author: David Goodger
:Contact: goodger_at_[hidden]
:date: $Date$
Modified: branches/fix-links/libs/ptr_container/doc/intro.xml
==============================================================================
--- branches/fix-links/libs/ptr_container/doc/intro.xml (original)
+++ branches/fix-links/libs/ptr_container/doc/intro.xml 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -1,3 +1,15 @@
+<!--
+//
+// Boost.Pointer Container
+//
+// Copyright Thorsten Ottosen 2003-2005. Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/ptr_container/
+//
+-->
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
Modified: branches/fix-links/libs/ptr_container/doc/ptr_container.xml
==============================================================================
--- branches/fix-links/libs/ptr_container/doc/ptr_container.xml (original)
+++ branches/fix-links/libs/ptr_container/doc/ptr_container.xml 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -1,3 +1,15 @@
+<!--
+//
+// Boost.Pointer Container
+//
+// Copyright Thorsten Ottosen 2003-2005. Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/ptr_container/
+//
+-->
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
Modified: branches/fix-links/libs/ptr_container/test/Jamfile.v2
==============================================================================
--- branches/fix-links/libs/ptr_container/test/Jamfile.v2 (original)
+++ branches/fix-links/libs/ptr_container/test/Jamfile.v2 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -1,3 +1,13 @@
+#//
+#// Boost.Pointer Container
+#//
+#// Copyright Thorsten Ottosen 2003-2008. Use, modification and
+#// distribution is subject to the Boost Software License, Version
+#// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+#// http://www.boost.org/LICENSE_1_0.txt)
+#//
+#// For more information, see http://www.boost.org/libs/ptr_container/
+#//
rule sc-test ( name : extra-sources * )
{
@@ -23,6 +33,5 @@
[ sc-test indirect_fun ]
[ sc-test serialization : /boost/serialization//boost_serialization ]
[ sc-test no_exceptions ]
-# [ sc-test BoostPolymorphicContainerTest ]
;
Deleted: branches/fix-links/libs/ptr_container/test/sequence_point.cpp
==============================================================================
--- branches/fix-links/libs/ptr_container/test/sequence_point.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,52 +0,0 @@
-#include <iostream>
-
-
-struct Fun
-{
- Fun()
- {
- std::cout << "fun" << std::endl;
- }
-
- template< class T >
- void operator()( T t )
- {
- }
-
- template< class T >
- Fun& operator,( T r )
- {
- return *this;
- }
-};
-
-template< class T >
-Fun foo( T t )
-{
- return Fun();
-}
-
-
-
-struct one
-{
- one()
- {
- std::cout <<"one" << std::endl;
- }
-};
-
-struct two
-{
- two()
- {
- std::cout <<"two" << std::endl;
- }
-};
-
-int main()
-{
- foo( one() )( two() );
-
- Fun(),one(),two(),one();
-}
Modified: branches/fix-links/libs/range/doc/Jamfile.v2
==============================================================================
Binary files. No diff available.
Modified: branches/fix-links/libs/range/doc/boost_range.html
==============================================================================
--- branches/fix-links/libs/range/doc/boost_range.html (original)
+++ branches/fix-links/libs/range/doc/boost_range.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -745,7 +745,13 @@
<hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2007
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
<br>
Modified: branches/fix-links/libs/range/doc/example.cpp
==============================================================================
--- branches/fix-links/libs/range/doc/example.cpp (original)
+++ branches/fix-links/libs/range/doc/example.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -1,3 +1,13 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2008. Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
#include <boost/range.hpp>
#include <iterator> // for std::iterator_traits, std::distance()
Modified: branches/fix-links/libs/range/doc/examples.html
==============================================================================
--- branches/fix-links/libs/range/doc/examples.html (original)
+++ branches/fix-links/libs/range/doc/examples.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -41,9 +41,16 @@
<li> array.cpp
</ul>
+
<hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2004
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
Modified: branches/fix-links/libs/range/doc/faq.html
==============================================================================
--- branches/fix-links/libs/range/doc/faq.html (original)
+++ branches/fix-links/libs/range/doc/faq.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -114,9 +114,16 @@
</ol>
- <hr>
+ <hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2004
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
Modified: branches/fix-links/libs/range/doc/headers.html
==============================================================================
--- branches/fix-links/libs/range/doc/headers.html (original)
+++ branches/fix-links/libs/range/doc/headers.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -173,7 +173,14 @@
<hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2007
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
Modified: branches/fix-links/libs/range/doc/history_ack.html
==============================================================================
--- branches/fix-links/libs/range/doc/history_ack.html (original)
+++ branches/fix-links/libs/range/doc/history_ack.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -61,7 +61,14 @@
<hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2006
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
Modified: branches/fix-links/libs/range/doc/intro.html
==============================================================================
--- branches/fix-links/libs/range/doc/intro.html (original)
+++ branches/fix-links/libs/range/doc/intro.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -135,7 +135,14 @@
<hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2007
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
Modified: branches/fix-links/libs/range/doc/portability.html
==============================================================================
--- branches/fix-links/libs/range/doc/portability.html (original)
+++ branches/fix-links/libs/range/doc/portability.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -73,11 +73,18 @@
</ol>
</p>
- <hr>
+ <hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2004
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+ </p>>
+
<br>
<br>
<br>
Modified: branches/fix-links/libs/range/doc/range.html
==============================================================================
--- branches/fix-links/libs/range/doc/range.html (original)
+++ branches/fix-links/libs/range/doc/range.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -352,34 +352,16 @@
<p> Boost Concept Check library</p>
<hr>
-
- <!--
- <h3>Notes</h3>
-
-
- <P>
- <A name="1">[1]</A>
-
- The reference type does not have to be a real C++ reference. The requirements of
- the reference type is that it <i>behaves</i> like a real reference. Hence the
- reference type must be convertible to the value_type and assignment through
-
- <br>
- <br>
- <HR>
- <br>
--->
-
- <TABLE>
- <TR valign="top">
- <TD nowrap>Copyright © 2000</TD>
- <TD><A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>
- </TR>
- <tr >
- <TD nowrap>Copyright © 2004-2007</TD>
- <TD>Thorsten Ottosen.
- </TABLE>
-
+ <p>
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
<br>
<br>
<br>
Modified: branches/fix-links/libs/range/doc/style.css
==============================================================================
--- branches/fix-links/libs/range/doc/style.css (original)
+++ branches/fix-links/libs/range/doc/style.css 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -1,3 +1,14 @@
+/*
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2008. Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+*/
pre{
BORDER-RIGHT: gray 1pt solid;
PADDING-RIGHT: 2pt;
Modified: branches/fix-links/libs/range/doc/style.html
==============================================================================
--- branches/fix-links/libs/range/doc/style.html (original)
+++ branches/fix-links/libs/range/doc/style.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -104,9 +104,15 @@
<hr>
<p>
- (C) Copyright Thorsten Ottosen 2003-2004
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
<br>
<br>
<br>
Modified: branches/fix-links/libs/range/doc/utility_class.html
==============================================================================
--- branches/fix-links/libs/range/doc/utility_class.html (original)
+++ branches/fix-links/libs/range/doc/utility_class.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -350,10 +350,17 @@
</pre>
</p>
-<hr>
- <p>
- (C) Copyright Thorsten Ottosen 2003-2007
- </p>
+ <hr>
+ <p>
+ © <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+ </p>
+
+ <p>
+ Distributed under the Boost Software License, Version 1.0. (See
+ accompanying file LICENSE_1_0.txt or copy
+ at <a href=
+ "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
<br>
<br>
Deleted: branches/fix-links/libs/range/test/TODO
==============================================================================
--- branches/fix-links/libs/range/test/TODO 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1 +0,0 @@
-
Deleted: branches/fix-links/libs/range/test/compat1.cpp
==============================================================================
Modified: branches/fix-links/libs/range/test/partial_workaround.cpp
==============================================================================
--- branches/fix-links/libs/range/test/partial_workaround.cpp (original)
+++ branches/fix-links/libs/range/test/partial_workaround.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -10,6 +10,8 @@
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/test/test_tools.hpp>
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
# pragma warn -8091 // supress warning in Boost.Test
@@ -30,7 +32,6 @@
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
-#include <boost/test/test_tools.hpp>
#include <iostream>
#include <vector>
@@ -91,6 +92,11 @@
void check_partial_workaround()
{
+ //
+ // test if warnings are generated
+ //
+ std::size_t s = boost::range_detail::array_size( "foo" );
+ BOOST_CHECK_EQUAL( s, 4u );
}
#endif
Modified: branches/fix-links/libs/regex/performance/input.html
==============================================================================
--- branches/fix-links/libs/regex/performance/input.html (original)
+++ branches/fix-links/libs/regex/performance/input.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -5,6 +5,7 @@
<meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5">
<meta name="Template" content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
+ <!-- boostinspect:nounlinked -->
</head>
<body bgcolor="#ffffff" link="#0000ff" vlink="#800080">
<h2>Regular Expression Performance Comparison</h2>
@@ -65,7 +66,7 @@
the text indicated was measured. </p>
<P>%short_matches%</P>
<hr>
- <p><i>© Copyright John Maddock 2003</i></p>
+ <p><i>© Copyright John Maddock 2003</i></p>
<p><i>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)</i></p>
Modified: branches/fix-links/libs/thread/test/test_mutex.cpp
==============================================================================
--- branches/fix-links/libs/thread/test/test_mutex.cpp (original)
+++ branches/fix-links/libs/thread/test/test_mutex.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -150,6 +150,17 @@
boost::system_time target = boost::get_system_time()+boost::posix_time::milliseconds(100);
BOOST_CHECK(lock.timed_lock(target));
BOOST_CHECK(lock ? true : false);
+ lock.unlock();
+ BOOST_CHECK(!lock);
+
+ BOOST_CHECK(mutex.timed_lock(boost::posix_time::milliseconds(100)));
+ mutex.unlock();
+
+ BOOST_CHECK(lock.timed_lock(boost::posix_time::milliseconds(100)));
+ BOOST_CHECK(lock ? true : false);
+ lock.unlock();
+ BOOST_CHECK(!lock);
+
}
};
Modified: branches/fix-links/libs/type_traits/cxx_type_traits.htm
==============================================================================
--- branches/fix-links/libs/type_traits/cxx_type_traits.htm (original)
+++ branches/fix-links/libs/type_traits/cxx_type_traits.htm 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -2,7 +2,8 @@
<html>
<head>
<meta http-equiv="refresh" content="0; URL=doc/html/boost_typetraits/background.html">
- </head>
+ <!-- boostinspect:nounlinked -->
+ </head>
<body><P>
Automatic redirection failed, please go to
<a href="doc/html/boost_typetraits/background.html">doc/html/boost_typetraits/background.html.</a></P>
Deleted: branches/fix-links/libs/type_traits/doc/html/boost_typetraits/category/background.html
==============================================================================
--- branches/fix-links/libs/type_traits/doc/html/boost_typetraits/category/background.html 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,699 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Background and Tutorial</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
-<link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../category.html" title="Type Traits by Category">
-<link rel="prev" href="../category.html" title="Type Traits by Category">
-<link rel="next" href="value_traits.html" title="Type Traits that Describe the Properties of a Type">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../category.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.category.background"></a><a href="background.html" title="Background and Tutorial"> Background and
- Tutorial</a>
-</h3></div></div></div>
-<p>
- The following is an updated version of the article "C++ Type traits"
- by John Maddock and Steve Cleary that appeared in the October 2000 issue
- of Dr Dobb's Journal.
- </p>
-<p>
- Generic programming (writing code which works with any data type meeting
- a set of requirements) has become the method of choice for providing reusable
- code. However, there are times in generic programming when "generic"
- just isn't good enough - sometimes the differences between types are too
- large for an efficient generic implementation. This is when the traits technique
- becomes important - by encapsulating those properties that need to be considered
- on a type by type basis inside a traits class, we can minimize the amount
- of code that has to differ from one type to another, and maximize the amount
- of generic code.
- </p>
-<p>
- Consider an example: when working with character strings, one common operation
- is to determine the length of a null terminated string. Clearly it's possible
- to write generic code that can do this, but it turns out that there are much
- more efficient methods available: for example, the C library functions <code class="computeroutput"><span class="identifier">strlen</span></code> and <code class="computeroutput"><span class="identifier">wcslen</span></code>
- are usually written in assembler, and with suitable hardware support can
- be considerably faster than a generic version written in C++. The authors
- of the C++ standard library realized this, and abstracted the properties
- of <code class="computeroutput"><span class="keyword">char</span></code> and <code class="computeroutput"><span class="keyword">wchar_t</span></code>
- into the class <code class="computeroutput"><span class="identifier">char_traits</span></code>.
- Generic code that works with character strings can simply use <code class="computeroutput"><span class="identifier">char_traits</span><span class="special"><>::</span><span class="identifier">length</span></code> to determine the length of a null
- terminated string, safe in the knowledge that specializations of <code class="computeroutput"><span class="identifier">char_traits</span></code> will use the most appropriate
- method available to them.
- </p>
-<a name="boost_typetraits.category.background.type_traits"></a><h5>
-<a name="id437674"></a>
- Type Traits
- </h5>
-<p>
- Class <code class="computeroutput"><span class="identifier">char_traits</span></code> is a classic
- example of a collection of type specific properties wrapped up in a single
- class - what Nathan Myers termed a <span class="emphasis"><em>baggage class</em></span>[1]. In the Boost type-traits library,
- we[2] have written a set of
- very specific traits classes, each of which encapsulate a single trait from
- the C++ type system; for example, is a type a pointer or a reference type?
- Or does a type have a trivial constructor, or a const-qualifier? The type-traits
- classes share a unified design: each class inherits from a the type true_type if
- the type has the specified property and inherits from false_type
- otherwise. As we will show, these classes can be used in generic programming
- to determine the properties of a given type and introduce optimizations that
- are appropriate for that case.
- </p>
-<p>
- The type-traits library also contains a set of classes that perform a specific
- transformation on a type; for example, they can remove a top-level const
- or volatile qualifier from a type. Each class that performs a transformation
- defines a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code>
- that is the result of the transformation. All of the type-traits classes
- are defined inside namespace <code class="computeroutput"><span class="identifier">boost</span></code>;
- for brevity, namespace-qualification is omitted in most of the code samples
- given.
- </p>
-<a name="boost_typetraits.category.background.implementation"></a><h5>
-<a name="id437797"></a>
- Implementation
- </h5>
-<p>
- There are far too many separate classes contained in the type-traits library
- to give a full implementation here - see the source code in the Boost library
- for the full details - however, most of the implementation is fairly repetitive
- anyway, so here we will just give you a flavor for how some of the classes
- are implemented. Beginning with possibly the simplest class in the library,
- <code class="computeroutput"><span class="identifier">is_void</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code> inherits
- from <code class="computeroutput">true_type</code>
- only if <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="keyword">void</span></code>.
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
-<span class="keyword">struct</span> is_void <span class="special">:</span> <span class="keyword">public</span> false_type<span class="special">{};</span>
-
-<span class="keyword">template</span> <span class="special"><></span>
-<span class="keyword">struct</span> is_void<span class="special"><</span><span class="keyword">void</span><span class="special">></span> <span class="special">:</span> <span class="keyword">public</span> true_type<span class="special">{};</span>
-</pre>
-<p>
- Here we define a primary version of the template class <code class="computeroutput">is_void</code>,
- and provide a full-specialization when <code class="computeroutput"><span class="identifier">T</span></code>
- is <code class="computeroutput"><span class="keyword">void</span></code>. While full specialization
- of a template class is an important technique, sometimes we need a solution
- that is halfway between a fully generic solution, and a full specialization.
- This is exactly the situation for which the standards committee defined partial
- template-class specialization. As an example, consider the class <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>:
- here we needed a primary version that handles all the cases where T is not
- a pointer, and a partial specialization to handle all the cases where T is
- a pointer:
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
-<span class="keyword">struct</span> is_pointer <span class="special">:</span> <span class="keyword">public</span> false_type<span class="special">{};</span>
-
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
-<span class="keyword">struct</span> is_pointer<span class="special"><</span><span class="identifier">T</span><span class="special">*></span> <span class="special">:</span> <span class="keyword">public</span> true_type<span class="special">{};</span>
-</pre>
-<p>
- The syntax for partial specialization is somewhat arcane and could easily
- occupy an article in its own right; like full specialization, in order to
- write a partial specialization for a class, you must first declare the primary
- template. The partial specialization contains an extra <...> after
- the class name that contains the partial specialization parameters; these
- define the types that will bind to that partial specialization rather than
- the default template. The rules for what can appear in a partial specialization
- are somewhat convoluted, but as a rule of thumb if you can legally write
- two function overloads of the form:
- </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span><span class="special">);</span>
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">U</span><span class="special">);</span>
-</pre>
-<p>
- Then you can also write a partial specialization of the form:
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
-<span class="keyword">class</span> <span class="identifier">c</span><span class="special">{</span> <span class="comment">/*details*/</span> <span class="special">};</span>
-
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
-<span class="keyword">class</span> <span class="identifier">c</span><span class="special"><</span><span class="identifier">U</span><span class="special">>{</span> <span class="comment">/*details*/</span> <span class="special">};</span>
-</pre>
-<p>
- This rule is by no means foolproof, but it is reasonably simple to remember
- and close enough to the actual rule to be useful for everyday use.
- </p>
-<p>
- As a more complex example of partial specialization consider the class <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>.
- This class defines a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code>
- that is the same type as T but with any top-level array bounds removed; this
- is an example of a traits class that performs a transformation on a type:
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
-<span class="keyword">struct</span> remove_extent
-<span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
-
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">></span>
-<span class="keyword">struct</span> remove_extent<span class="special"><</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]></span>
-<span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
-</pre>
-<p>
- The aim of <code class="computeroutput">remove_extent</code>
- is this: imagine a generic algorithm that is passed an array type as a template
- parameter, <code class="computeroutput">remove_extent</code>
- provides a means of determining the underlying type of the array. For example
- <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special"><</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]>::</span><span class="identifier">type</span></code> would evaluate to the type <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>. This example also shows that the number
- of template parameters in a partial specialization does not have to match
- the number in the default template. However, the number of parameters that
- appear after the class name do have to match the number and type of the parameters
- in the default template.
- </p>
-<a name="boost_typetraits.category.background.optimized_copy"></a><h5>
-<a name="id490244"></a>
- <a href="background.html#boost_typetraits.category.background.optimized_copy">Optimized
- copy</a>
- </h5>
-<p>
- As an example of how the type traits classes can be used, consider the standard
- library algorithm copy:
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Iter1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Iter2</span><span class="special">></span>
-<span class="identifier">Iter2</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">Iter1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iter1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Iter2</span> <span class="identifier">out</span><span class="special">);</span>
-</pre>
-<p>
- Obviously, there's no problem writing a generic version of copy that works
- for all iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code>
- and <code class="computeroutput"><span class="identifier">Iter2</span></code>; however, there
- are some circumstances when the copy operation can best be performed by a
- call to <code class="computeroutput"><span class="identifier">memcpy</span></code>. In order
- to implement copy in terms of <code class="computeroutput"><span class="identifier">memcpy</span></code>
- all of the following conditions need to be met:
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- Both of the iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code>
- and <code class="computeroutput"><span class="identifier">Iter2</span></code> must be pointers.
- </li>
-<li>
- Both <code class="computeroutput"><span class="identifier">Iter1</span></code> and <code class="computeroutput"><span class="identifier">Iter2</span></code> must point to the same type - excluding
- const and volatile-qualifiers.
- </li>
-<li>
- The type pointed to by <code class="computeroutput"><span class="identifier">Iter1</span></code>
- must have a trivial assignment operator.
- </li>
-</ul></div>
-<p>
- By trivial assignment operator we mean that the type is either a scalar type[3] or:
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- The type has no user defined assignment operator.
- </li>
-<li>
- The type does not have any data members that are references.
- </li>
-<li>
- All base classes, and all data member objects must have trivial assignment
- operators.
- </li>
-</ul></div>
-<p>
- If all these conditions are met then a type can be copied using <code class="computeroutput"><span class="identifier">memcpy</span></code> rather than using a compiler generated
- assignment operator. The type-traits library provides a class <code class="computeroutput">has_trivial_assign</code>,
- such that <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> is true only if T has a trivial assignment
- operator. This class "just works" for scalar types, but has to
- be explicitly specialised for class/struct types that also happen to have
- a trivial assignment operator. In other words if has_trivial_assign
- gives the wrong answer, it will give the "safe" wrong answer -
- that trivial assignment is not allowable.
- </p>
-<p>
- The code for an optimized version of copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code>
- where appropriate is given in the examples.
- The code begins by defining a template function <code class="computeroutput"><span class="identifier">do_copy</span></code>
- that performs a "slow but safe" copy. The last parameter passed
- to this function may be either a <code class="computeroutput">true_type</code>
- or a <code class="computeroutput">false_type</code>.
- Following that there is an overload of do<span class="underline">copy
- that uses `memcpy`: this time the iterators are required to actually be pointers
- to the same type, and the final parameter must be a `</span>_true_type<code class="computeroutput"><span class="special">.</span> <span class="identifier">Finally</span><span class="special">,</span> <span class="identifier">the</span> <span class="identifier">version</span> <span class="identifier">of</span>
- </code>copy<code class="computeroutput"> <span class="identifier">calls</span> </code>do<span class="underline">copy`, passing `</span>_has_trivial_assign<value_type>()`
- as the final parameter: this will dispatch to the optimized version where
- appropriate, otherwise it will call the "slow but safe version".
- </p>
-<a name="boost_typetraits.category.background.was_it_worth_it_"></a><h5>
-<a name="id490786"></a>
- <a href="background.html#boost_typetraits.category.background.was_it_worth_it_">Was
- it worth it?</a>
- </h5>
-<p>
- It has often been repeated in these columns that "premature optimization
- is the root of all evil" [4].
- So the question must be asked: was our optimization premature? To put this
- in perspective the timings for our version of copy compared a conventional
- generic copy[5] are shown in
- table 1.
- </p>
-<p>
- Clearly the optimization makes a difference in this case; but, to be fair,
- the timings are loaded to exclude cache miss effects - without this accurate
- comparison between algorithms becomes difficult. However, perhaps we can
- add a couple of caveats to the premature optimization rule:
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- If you use the right algorithm for the job in the first place then optimization
- will not be required; in some cases, memcpy is the right algorithm.
- </li>
-<li>
- If a component is going to be reused in many places by many people then
- optimizations may well be worthwhile where they would not be so for a single
- case - in other words, the likelihood that the optimization will be absolutely
- necessary somewhere, sometime is that much higher. Just as importantly
- the perceived value of the stock implementation will be higher: there is
- no point standardizing an algorithm if users reject it on the grounds that
- there are better, more heavily optimized versions available.
- </li>
-</ul></div>
-<div class="table">
-<a name="id490853"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy<const
- T*, T*>` (times in micro-seconds)</b></p>
-<div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy<const
- T*, T*>` (times in micro-seconds)">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Version
- </p>
- </th>
-<th>
- <p>
- T
- </p>
- </th>
-<th>
- <p>
- Time
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- "Optimized" copy
- </p>
- </td>
-<td>
- <p>
- char
- </p>
- </td>
-<td>
- <p>
- 0.99
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Conventional copy
- </p>
- </td>
-<td>
- <p>
- char
- </p>
- </td>
-<td>
- <p>
- 8.07
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- "Optimized" copy
- </p>
- </td>
-<td>
- <p>
- int
- </p>
- </td>
-<td>
- <p>
- 2.52
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Conventional copy
- </p>
- </td>
-<td>
- <p>
- int
- </p>
- </td>
-<td>
- <p>
- 8.02
- </p>
- </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><a name="boost_typetraits.category.background.pair_of_references"></a><h5>
-<a name="id491010"></a>
- <a href="background.html#boost_typetraits.category.background.pair_of_references">Pair
- of References</a>
- </h5>
-<p>
- The optimized copy example shows how type traits may be used to perform optimization
- decisions at compile-time. Another important usage of type traits is to allow
- code to compile that otherwise would not do so unless excessive partial specialization
- is used. This is possible by delegating partial specialization to the type
- traits classes. Our example for this form of usage is a pair that can hold
- references [6].
- </p>
-<p>
- First, let us examine the definition of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>,
- omitting the comparison operators, default constructor, and template copy
- constructor for simplicity:
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">></span>
-<span class="keyword">struct</span> <span class="identifier">pair</span>
-<span class="special">{</span>
-<span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span>
-
-<span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span>
-<span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span>
-
-<span class="identifier">pair</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T1</span> <span class="special">&</span> <span class="identifier">nfirst</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T2</span> <span class="special">&</span> <span class="identifier">nsecond</span><span class="special">)</span>
-<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- Now, this "pair" cannot hold references as it currently stands,
- because the constructor would require taking a reference to a reference,
- which is currently illegal [7].
- Let us consider what the constructor's parameters would have to be in order
- to allow "pair" to hold non-reference types, references, and constant
- references:
- </p>
-<div class="table">
-<a name="id491374"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
-<div class="table-contents"><table class="table" summary="Required Constructor Argument Types">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Type of <code class="computeroutput"><span class="identifier">T1</span></code>
- </p>
- </th>
-<th>
- <p>
- Type of parameter to initializing constructor
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- T
- </p>
- </td>
-<td>
- <p>
- const T &
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- T &
- </p>
- </td>
-<td>
- <p>
- T &
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- const T &
- </p>
- </td>
-<td>
- <p>
- const T &
- </p>
- </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
- A little familiarity with the type traits classes allows us to construct
- a single mapping that allows us to determine the type of parameter from the
- type of the contained class. The type traits classes provide a transformation
- add_reference,
- which adds a reference to its type, unless it is already a reference.
- </p>
-<div class="table">
-<a name="id491508"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor
- type</b></p>
-<div class="table-contents"><table class="table" summary="Using add_reference to synthesize the correct constructor
- type">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Type of <code class="computeroutput"><span class="identifier">T1</span></code>
- </p>
- </th>
-<th>
- <p>
- Type of <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">T1</span></code>
- </p>
- </th>
-<th>
- <p>
- Type of <code class="computeroutput"><span class="identifier">add_reference</span><span class="special"><</span><span class="keyword">const</span>
- <span class="identifier">T1</span><span class="special">>::</span><span class="identifier">type</span></code>
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- T
- </p>
- </td>
-<td>
- <p>
- const T
- </p>
- </td>
-<td>
- <p>
- const T &
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- T &
- </p>
- </td>
-<td>
- <p>
- T & [8]
- </p>
- </td>
-<td>
- <p>
- T &
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- const T &
- </p>
- </td>
-<td>
- <p>
- const T &
- </p>
- </td>
-<td>
- <p>
- const T &
- </p>
- </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
- This allows us to build a primary template definition for <code class="computeroutput"><span class="identifier">pair</span></code>
- that can contain non-reference types, reference types, and constant reference
- types:
- </p>
-<pre class="programlisting">
-<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">></span>
-<span class="keyword">struct</span> <span class="identifier">pair</span>
-<span class="special">{</span>
-<span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span>
-
-<span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span>
-<span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span>
-
-<span class="identifier">pair</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span>add_reference<span class="special"><</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">nfirst</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span>add_reference<span class="special"><</span><span class="keyword">const</span> <span class="identifier">T2</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">nsecond</span><span class="special">)</span>
-<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- Add back in the standard comparison operators, default constructor, and template
- copy constructor (which are all the same), and you have a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>
- that can hold reference types!
- </p>
-<p>
- This same extension could have been done using partial template specialization
- of <code class="computeroutput"><span class="identifier">pair</span></code>, but to specialize
- <code class="computeroutput"><span class="identifier">pair</span></code> in this way would require
- three partial specializations, plus the primary template. Type traits allows
- us to define a single primary template that adjusts itself auto-magically
- to any of these partial specializations, instead of a brute-force partial
- specialization approach. Using type traits in this fashion allows programmers
- to delegate partial specialization to the type traits classes, resulting
- in code that is easier to maintain and easier to understand.
- </p>
-<a name="boost_typetraits.category.background.conclusion"></a><h5>
-<a name="id492124"></a>
- Conclusion
- </h5>
-<p>
- We hope that in this article we have been able to give you some idea of what
- type-traits are all about. A more complete listing of the available classes
- are in the boost documentation, along with further examples using type traits.
- Templates have enabled C++ uses to take the advantage of the code reuse that
- generic programming brings; hopefully this article has shown that generic
- programming does not have to sink to the lowest common denominator, and that
- templates can be optimal as well as generic.
- </p>
-<a name="boost_typetraits.category.background.acknowledgements"></a><h5>
-<a name="id492161"></a>
- Acknowledgements
- </h5>
-<p>
- The authors would like to thank Beman Dawes and Howard Hinnant for their
- helpful comments when preparing this article.
- </p>
-<a name="boost_typetraits.category.background.references"></a><h5>
-<a name="id492191"></a>
- References
- </h5>
-<div class="orderedlist"><ol type="1">
-<li>
- Nathan C. Myers, C++ Report, June 1995.
- </li>
-<li>
- The type traits library is based upon contributions by Steve Cleary, Beman
- Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.
- </li>
-<li>
- A scalar type is an arithmetic type (i.e. a built-in integer or floating
- point type), an enumeration type, a pointer, a pointer to member, or a
- const- or volatile-qualified version of one of these types.
- </li>
-<li>
- This quote is from Donald Knuth, ACM Computing Surveys, December 1974,
- pg 268.
- </li>
-<li>
- The test code is available as part of the boost utility library (see algo_opt_examples.cpp),
- the code was compiled with gcc 2.95 with all optimisations turned on, tests
- were conducted on a 400MHz Pentium II machine running Microsoft Windows
- 98.
- </li>
-<li>
- John Maddock and Howard Hinnant have submitted a "compressed_pair"
- library to Boost, which uses a technique similar to the one described here
- to hold references. Their pair also uses type traits to determine if any
- of the types are empty, and will derive instead of contain to conserve
- space -- hence the name "compressed".
- </li>
-<li>
- This is actually an issue with the C++ Core Language Working Group (issue
- #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow
- a "reference to a reference to T" to mean the same thing as a
- "reference to T", but only in template instantiation, in a method
- similar to multiple cv-qualifiers.
- </li>
-<li>
- For those of you who are wondering why this shouldn't be const-qualified,
- remember that references are always implicitly constant (for example, you
- can't re-assign a reference). Remember also that "const T &"
- is something completely different. For this reason, cv-qualifiers on template
- type arguments that are references are ignored.
- </li>
-</ol></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><small>Copyright © 2000, 2006 Adobe Systems Inc, David Abrahams,
- Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
- Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
- Ramey and Jeremy Siek</small></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../category.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
Modified: branches/fix-links/libs/unordered/test/exception/assign_exception_tests.cpp
==============================================================================
--- branches/fix-links/libs/unordered/test/exception/assign_exception_tests.cpp (original)
+++ branches/fix-links/libs/unordered/test/exception/assign_exception_tests.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -36,10 +36,14 @@
const test::random_values<T> x_values, y_values;
const T x,y;
+ typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
+ typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
+ typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
assign_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
: x_values(count1), y_values(count2),
- x(x_values.begin(), x_values.end(), 0, BOOST_DEDUCED_TYPENAME T::hasher(tag1), BOOST_DEDUCED_TYPENAME T::key_equal(tag1), BOOST_DEDUCED_TYPENAME T::allocator_type(tag1)),
- y(y_values.begin(), y_values.end(), 0, BOOST_DEDUCED_TYPENAME T::hasher(tag2), BOOST_DEDUCED_TYPENAME T::key_equal(tag2), BOOST_DEDUCED_TYPENAME T::allocator_type(tag2)) {}
+ x(x_values.begin(), x_values.end(), 0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
+ y(y_values.begin(), y_values.end(), 0, hasher(tag2), key_equal(tag2), allocator_type(tag2)) {}
typedef T data_type;
T init() const { return T(x); }
Modified: branches/fix-links/libs/unordered/test/exception/swap_exception_tests.cpp
==============================================================================
--- branches/fix-links/libs/unordered/test/exception/swap_exception_tests.cpp (original)
+++ branches/fix-links/libs/unordered/test/exception/swap_exception_tests.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -48,12 +48,16 @@
const test::random_values<T> x_values, y_values;
const T initial_x, initial_y;
+ typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
+ typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
+ typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
swap_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
: x_values(count1), y_values(count2),
- initial_x(x_values.begin(), x_values.end(), 0, BOOST_DEDUCED_TYPENAME T::hasher(tag1),
- BOOST_DEDUCED_TYPENAME T::key_equal(tag1), BOOST_DEDUCED_TYPENAME T::allocator_type(tag1)),
- initial_y(y_values.begin(), y_values.end(), 0, BOOST_DEDUCED_TYPENAME T::hasher(tag2),
- BOOST_DEDUCED_TYPENAME T::key_equal(tag2), BOOST_DEDUCED_TYPENAME T::allocator_type(tag2))
+ initial_x(x_values.begin(), x_values.end(), 0, hasher(tag1),
+ key_equal(tag1), allocator_type(tag1)),
+ initial_y(y_values.begin(), y_values.end(), 0, hasher(tag2),
+ key_equal(tag2), allocator_type(tag2))
{}
struct data_type {
Modified: branches/fix-links/libs/unordered/test/unordered/equivalent_keys_tests.cpp
==============================================================================
--- branches/fix-links/libs/unordered/test/unordered/equivalent_keys_tests.cpp (original)
+++ branches/fix-links/libs/unordered/test/unordered/equivalent_keys_tests.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -8,7 +8,7 @@
#include <boost/detail/lightweight_test.hpp>
#include <algorithm>
#include <map>
-#include <deque>
+#include <list>
#include "../helpers/tracker.hpp"
#include "../helpers/invariants.hpp"
@@ -57,7 +57,7 @@
void map_tests()
{
- typedef std::deque<std::pair<int const, int> > values_type;
+ typedef std::list<std::pair<int const, int> > values_type;
values_type v[5];
v[0].push_back(std::pair<int const, int>(1,1));
v[1].push_back(std::pair<int const, int>(28,34));
Modified: branches/fix-links/libs/wave/samples/cpp_tokens/slex_token.hpp
==============================================================================
--- branches/fix-links/libs/wave/samples/cpp_tokens/slex_token.hpp (original)
+++ branches/fix-links/libs/wave/samples/cpp_tokens/slex_token.hpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -14,6 +14,7 @@
#define SLEX_TOKEN_HPP_53A13BD2_FBAA_444B_9B8B_FCB225C2BBA8_INCLUDED
#include <iomanip>
+#include <ios>
#include <boost/wave/wave_config.hpp>
#include <boost/wave/token_ids.hpp>
@@ -82,11 +83,13 @@
{
using namespace std;
using namespace boost::wave;
- stream << setw(16) << left << boost::wave::get_token_name(id) << " ("
+
+ stream << std::setw(16)
+ << std::left << boost::wave::get_token_name(id) << " ("
<< "#" << token_id(ID_FROM_TOKEN(*this))
<< ") at " << get_position().get_file() << " ("
- << setw(3) << right << get_position().get_line() << "/"
- << setw(2) << right << get_position().get_column()
+ << std::setw(3) << std::right << get_position().get_line() << "/"
+ << std::setw(2) << std::right << get_position().get_column()
<< "): >";
for (std::size_t i = 0; i < value.size(); ++i) {
Modified: branches/fix-links/libs/xpressive/proto/doc/Jamfile.v2
==============================================================================
--- branches/fix-links/libs/xpressive/proto/doc/Jamfile.v2 (original)
+++ branches/fix-links/libs/xpressive/proto/doc/Jamfile.v2 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -6,7 +6,7 @@
import doxygen ;
import quickbook ;
-#wave-command = [ path.native ../../../../dist/bin/wave ] ;
+wave-command = [ path.native ../../../../dist/bin/wave ] ;
# Generate reference section using Doxygen
doxygen protodoc
@@ -47,15 +47,15 @@
<doxygen:param>EXTRACT_ALL=YES
<doxygen:param>HIDE_UNDOC_MEMBERS=NO
# Use Boost.Wave to preprocess Proto's source
- <doxygen:param>INPUT_FILTER=./wave.sh
-# <doxygen:param>"INPUT_FILTER=\"$(wave-command) \\
-# -S ../../../.. \\
-# -S \\\"C:\\Program Files\\Microsoft Visual Studio .NET 2003\\vc7\\include\\\" \\
-# -D _WIN32 \\
-# -D BOOST_PROTO_DOXYGEN_INVOKED \\
-# -p 1 \""
-# # This ensures that Wave is actually built before we try to execute it
-# <dependency>../../../../tools/wave/build release
+# <doxygen:param>INPUT_FILTER=./wave.sh
+ <doxygen:param>"INPUT_FILTER=\"$(wave-command) \\
+ -S ../../../.. \\
+ -S \\\"C:\\Program Files\\Microsoft Visual Studio .NET 2003\\vc7\\include\\\" \\
+ -D _WIN32 \\
+ -D BOOST_PROTO_DOXYGEN_INVOKED \\
+ -p 1 \""
+ # This ensures that Wave is actually built before we try to execute it
+ <dependency>../../../../tools/wave/build release
;
xml proto
@@ -104,5 +104,5 @@
# better use SVG's instead:
# <xsl:param>admon.graphics.extension=".svg"
- <dependency>protodoc
+# <dependency>protodoc
;
Modified: branches/fix-links/libs/xpressive/proto/doc/evaluation.qbk
==============================================================================
--- branches/fix-links/libs/xpressive/proto/doc/evaluation.qbk (original)
+++ branches/fix-links/libs/xpressive/proto/doc/evaluation.qbk 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -7,12 +7,98 @@
[section:expression_evaluation Expression Evaluation: Imparting Behaviors Within A Context]
+Once you have constructed a Proto expression tree, either by using Proto's
+operator overloads or with _make_expr_ and friends, you probably want to
+actually /do/ something with it. The simplest option is to use `proto::eval()`,
+a generic expression evaluator. To use _eval_, you'll need to define a
+/context/ that tells _eval_ how each node should be evaluated. This section
+goes through the nuts and bolts of using _eval_, defining evaluation contexts,
+and using the contexts that Proto provides.
+
+[note `proto::eval()` is a less powerful but easier-to-use evaluation technique
+than Proto transforms, which are covered later. Although very powerful,
+transforms have a steep learning curve and can be more difficult to debug.
+`proto::eval()` is a rather weak tree traversal algorithm. Dan Marsden has
+been working on a more general and powerful tree traversal library. When it is
+ready, I anticipate that it will eliminate the need for `proto::eval()`.]
+
[/================================================================]
[section:proto_eval Evaluating An Expression with [^proto::eval()]]
[/================================================================]
+[:[*Synopsis:]]
-
+ namespace proto
+ {
+ namespace result_of
+ {
+ // A metafunction for calculating the return
+ // type of proto::eval() given certain Expr
+ // and Context types.
+ template<typename Expr, typename Context>
+ struct eval
+ {
+ typedef
+ typename Context::template eval<Expr>::result_type
+ type;
+ };
+ }
+
+ namespace functional
+ {
+ // A callable function object type for evaluating
+ // a Proto expression with a certain context.
+ struct eval : callable
+ {
+ template<typename Sig>
+ struct result;
+
+ template<typename Expr, typename Context>
+ typename proto::result_of::eval<Expr, Context>::type
+ operator ()(Expr &expr, Context &context) const;
+
+ template<typename Expr, typename Context>
+ typename proto::result_of::eval<Expr, Context>::type
+ operator ()(Expr &expr, Context const &context) const;
+ };
+ }
+
+ functional::eval const eval = {};
+ }
+
+Given an expression and an evaluation context, using _eval_ is quite simple.
+Simply pass the expression and the context to _eval_ and it does the rest and
+returns the result. You can use the `eval<>` metafunction in the
+`proto::result_of` namespace to compute the return type of _eval_. The
+following demonstrates a use of _eval_:
+
+ template<typename Expr>
+ typename proto::result_of::eval<Expr const, MyContext>::type
+ MyEvaluate(Expr const &expr)
+ {
+ // Some user-defined context type
+ MyContext ctx;
+
+ // Evaluate an expression with the context
+ return proto::eval(expr, ctx);
+ }
+
+What _eval_ does is also very simple. It defers most of the work to the
+context itself. Here essentially is the implementation of _eval_:
+
+ // eval() dispatches to a nested "eval<>" function
+ // object within the Context:
+ template<typename Expr, typename Context>
+ typename Context::template eval<Expr>::result_type
+ eval(Expr &expr, Context &ctx)
+ {
+ typename Context::template eval<Expr> eval_fun;
+ return eval_fun(expr, ctx);
+ }
+
+Really, _eval_ is nothing more than a thin wrapper that dispatches to the
+appropriate handler within the context class. In the next section, we'll see
+how to implement a context class from scratch.
[endsect]
@@ -20,7 +106,138 @@
[section:contexts Defining an Evaluation Context]
[/==============================================]
-TODO
+As we saw in the previous section, there is really not much to the _eval_
+function. Rather, all the interesting expression evaluation goes on within
+a context class. This sections shows how to implement one from scratch.
+
+All context classes have roughly the following form:
+
+ // A prototypical user-defined context.
+ struct MyContext
+ {
+ // A nested eval<> class template
+ template<
+ typename Expr
+ , typename Tag = typename Expr::proto_tag
+ >
+ struct eval;
+
+ // Handle terminal nodes here...
+ template<typename Expr>
+ struct eval<Expr, proto::tag::terminal>
+ {
+ // Must have a nested result_type typedef.
+ typedef ... result_type;
+
+ // Must have a function call operator that takes
+ // an expression and the context.
+ result_type operator()(Expr &expr, MyContext &ctx) const
+ {
+ return ...;
+ }
+ };
+
+ // ... other specializations of struct eval<> ...
+ };
+
+Context classes are nothing more than a collection of specializations of a
+nested `eval<>` class template. Each specialization handles a different
+expression type.
+
+In the [link boost_proto.users_guide.hello_calculator Hello Calculator]
+section, we saw an example of a user-defined context class for evaluating
+calculator expressions. That context class was implemented with the help
+of Proto's _callable_context_. If we were to implement it from scratch, it
+would look something like this:
+
+ // The calculator_contest from the "Hello Calculator" section,
+ // implemented from scratch.
+ struct calculator_context
+ {
+ // The values for the _1 and _2 placeholders are
+ // passed to the calculator_context constructor.
+ calculator_context(double d1, double d2)
+ : d1_(d1), d2_(d2)
+ {}
+
+ template<
+ typename Expr
+ // defaulted template parameters, so we can
+ // specialize on the expressions that need
+ // special handling.
+ , typename Tag = typename tag_of<Expr>::type
+ , typename Arg0 = typename arg_c<Expr, 0>::type
+ >
+ struct eval;
+
+ // Handle placeholder1 terminals here...
+ template<typename Expr>
+ struct eval<Expr, proto::tag::terminal, placeholder1>
+ {
+ typedef double result_type;
+
+ result_type operator()(Expr &, MyContext &ctx) const
+ {
+ // replaces _1 with the value in ctx.d1_
+ return ctx.d1_;
+ }
+ };
+
+ // Handle placeholder2 terminals here...
+ template<typename Expr>
+ struct eval<Expr, proto::tag::terminal, placeholder2>
+ {
+ typedef double result_type;
+
+ result_type operator()(Expr &, MyContext &ctx) const
+ {
+ // replaces _1 with the value in ctx.d2_
+ return ctx.d2_;
+ }
+ };
+
+ // Handle other terminals here...
+ template<typename Expr, typename Arg0>
+ struct eval<Expr, proto::tag::terminal, Arg0>
+ {
+ typedef double result_type;
+
+ result_type operator()(Expr &expr, MyContext &) const
+ {
+ return proto::arg(expr);
+ }
+ };
+
+ // Handle addition here...
+ template<typename Expr, typename Arg0>
+ struct eval<Expr, proto::tag::plus, Arg0>
+ {
+ typedef double result_type;
+
+ result_type operator()(Expr &expr, MyContext &ctx) const
+ {
+ return proto::eval(proto::left(expr), ctx)
+ + proto::eval(proto::right(expr), ctx);
+ }
+ };
+
+ // ... other eval<> specializations for other node types ...
+
+ double d1_, d2_;
+ };
+
+Now we can use _eval_ with the context class above to evaluate calculator
+expressions as follows:
+
+ // Evaluate an expression with a calculator_context
+ double d = proto::eval(_1 + _2, calculator_context(5, 6));
+ assert(11 == d);
+
+Defining a context from scratch this way is tedious and verbose, but it gives
+you complete control over how the expression is evaluated. The context class in
+the [link boost_proto.users_guide.hello_calculator Hello Calculator] example
+was much simpler. In the next section we'll see the helper class Proto provides
+to ease the job of implementing context classes.
[endsect]
@@ -28,11 +245,113 @@
[section:canned_contexts Canned Contexts]
[/======================================]
+Proto provides some ready-made context classes that you can use as-is, or that
+you can use to help while implementing your own contexts. They are:
+
+[variablelist
+ [ [[link boost_proto.users_guide.expression_evaluation.canned_contexts.default_context [^default_context]]]
+ [An evaluation context that assigns the usual C++ meanings to all the
+ operators. For example, addition nodes are handled by evaluating the
+ left and right children and then adding the results. The _default_context_
+ uses Boost.Typeof to deduce the types of the expressions it evaluates.] ]
+ [ [[link boost_proto.users_guide.expression_evaluation.canned_contexts.null_context [^null_context]]]
+ [A simple context that recursively evaluates children but does not combine
+ the results in any way and returns void.] ]
+ [ [[link boost_proto.users_guide.expression_evaluation.canned_contexts.callable_context [^callable_context<>]]]
+ [A helper that simplifies the job of writing context classes. Rather than
+ writing template specializations, with _callable_context_ you write a
+ function object with an overloaded function call operator. Any expressions
+ not handled by an overload are automatically dispatched to a default
+ evaluation context that you can specify.] ]
+]
+
[/=========================================]
[section:default_context [^default_context]]
[/=========================================]
-TODO
+The _default_context_ is an evaluation context that assigns the usual C++
+meanings to all the operators. For example, addition nodes are handled by
+evaluating the left and right children and then adding the results. The
+_default_context_ uses Boost.Typeof to deduce the types of the expressions it
+evaluates.
+
+For example, consider the following "Hello World" example:
+
+ #include <iostream>
+ #include <boost/xpressive/proto/proto.hpp>
+ #include <boost/xpressive/proto/context.hpp>
+ #include <boost/typeof/std/ostream.hpp>
+ using namespace boost;
+
+ proto::terminal< std::ostream & >::type cout_ = { std::cout };
+
+ template< typename Expr >
+ void evaluate( Expr const & expr )
+ {
+ // Evaluate the expression with default_context,
+ // to give the operators their C++ meanings:
+ proto::default_context ctx;
+ proto::eval(expr, ctx);
+ }
+
+ int main()
+ {
+ evaluate( cout_ << "hello" << ',' << " world" );
+ return 0;
+ }
+
+This program outputs the following:
+
+[pre
+hello, world
+]
+
+_default_context_ is trivially defined in terms of a `default_eval<>`
+template, as follows:
+
+ // Definition of default_context
+ struct default_context
+ {
+ template<typename Expr>
+ struct eval
+ : default_eval<Expr, default_context const, typename Expr::proto_tag>
+ {};
+ };
+
+There are a bunch of `default_eval<>` specializations, each of which handles
+a different C++ operator. Here, for instance, is the specialization for binary
+addition:
+
+ // A default expression evaluator for binary addition
+ template<typename Expr, typename Context>
+ struct default_eval<Expr, Context, proto::tag::plus>
+ {
+ private:
+ static Expr & s_expr;
+ static Context & s_ctx;
+
+ public:
+ typedef
+ decltype(
+ proto::eval(proto::arg_c<0>(s_expr), s_ctx)
+ + proto::eval(proto::arg_c<1>(s_expr), s_ctx)
+ )
+ result_type;
+
+ result_type operator ()(Expr &expr, Context &ctx) const
+ {
+ return proto::eval(proto::arg_c<0>(expr), ctx)
+ + proto::eval(proto::arg_c<1>(expr), ctx);
+ }
+ };
+
+The above code uses `decltype` to calculate the return type of the function
+call operator. `decltype` is a new keyword in the next version of C++ that gets
+the type of any expression. Most compilers do not yet support `decltype`
+directly, so `default_eval<>` uses the Boost.Typeof library to emulate it. On
+some compilers, that may mean that `default_context` either doesn't work or
+that it requires you to register your types with the Boost.Typeof library.
+Check the documentation for Boost.Typeof to see.
[endsect]
@@ -40,7 +359,67 @@
[section:null_context [^null_context]]
[/===================================]
-TODO
+The _null_context_ is a simple context that recursively evaluates children
+but does not combine the results in any way and returns void. It is useful
+in conjunction with `callable_context<>`, or when defining your own contexts
+which mutate an expression tree in-place rather than accumulate a result, as
+we'll see below.
+
+_null_context_ is trivially implemented in terms of `null_eval<>` as follows:
+
+ // Definition of null_context
+ struct null_context
+ {
+ template<typename Expr>
+ struct eval
+ : null_eval<Expr, null_context const, Expr::proto_arity::value>
+ {};
+ };
+
+And `null_eval<>` is also trivially implemented. Here, for instance is
+a binary `null_eval<>`:
+
+ // Binary null_eval<>
+ template<typename Expr, typename Context>
+ struct null_eval<Expr, Context, 2>
+ {
+ typedef void result_type;
+
+ void operator()(Expr &expr, Context &ctx) const
+ {
+ proto::eval(proto::arg_c<0>(expr), ctx);
+ proto::eval(proto::arg_c<1>(expr), ctx);
+ }
+ };
+
+When would such classes be useful? Imagine you have an expression tree with
+integer terminals, and you would like to increment each integer in-place. You
+might define an evaluation context as follows:
+
+ struct increment_ints
+ {
+ // By default, just evaluate all children by defering
+ // to the null_eval<>
+ template<typename Expr, typename Arg = proto::result_of::arg<Expr>::type>
+ struct eval
+ : null_eval<Expr, increment_ints const>
+ {};
+
+ // Increment integer terminals
+ template<typename Expr>
+ struct eval<Expr, int>
+ {
+ typedef void result_type;
+
+ void operator()(Expr &expr, increment_ints const &) const
+ {
+ ++proto::arg(expr);
+ }
+ };
+ };
+
+In the next section on _callable_context_, we'll see an even simpler way to
+achieve the same thing.
[endsect]
@@ -48,7 +427,130 @@
[section:callable_context [^callable_context<>]]
[/=============================================]
-TODO
+The _callable_context_ is a helper that simplifies the job of writing context
+classes. Rather than writing template specializations, with _callable_context_
+you write a function object with an overloaded function call operator. Any
+expressions not handled by an overload are automatically dispatched to a
+default evaluation context that you can specify.
+
+Rather than an evaluation context in its own right, _callable_context_ is more
+properly thought of as a context adaptor. To use it, you must define your own
+context that inherits from _callable_context_.
+
+In the [link boost_proto.users_guide.expression_evaluation.canned_contexts.null_context [^null_context]]
+section, we saw how to implement an evaluation context that increments all the
+integers within an expression tree. Here is how to do the same thing with the
+_callable_context_:
+
+ // An evaluation context that increments all
+ // integer terminals in-place.
+ struct increment_ints
+ : callable_context<
+ increment_ints const // derived context
+ , null_context const // fall-back context
+ >
+ {
+ typedef void result_type;
+
+ // Handle int terminals here:
+ void operator()(proto::tag::terminal, int &i) const
+ {
+ ++i;
+ }
+ };
+
+With such a context, we can do the following:
+
+ literal<int> i = 0, j = 10;
+ proto::eval( i - j * 3.14, increment_ints() );
+
+ std::cout << "i = " << i.get() << std::endl;
+ std::cout << "j = " << j.get() << std::endl;
+
+This program outputs the following, which shows that the integers `i` and `j`
+have been incremented by `1`:
+
+[pre
+i = 1
+j = 11
+]
+
+In the `increment_ints` context, we didn't have to define any nested `eval<>`
+templates. That's because _callable_context_ implements them for us.
+_callable_context_ takes two template parameters: the derived context and a
+fall-back context. For each node in the expression tree being evaluated,
+_callable_context_ checks to see if there is an overloaded `operator()` in the
+derived context that accepts it. Given some expression `expr` of type `Expr`,
+and a context `ctx`, it attempts to call:
+
+ ctx(
+ typename Expr::proto_tag()
+ , proto::arg_c<0>(expr)
+ , proto::arg_c<1>(expr)
+ ...
+ );
+
+Using function overloading and metaprogramming tricks, _callable_context_ can
+detect at compile-time whether such a function exists or not. If so, that
+function is called. If not, the current expression is passed to the fall-back
+evaluation context to be processed.
+
+We saw another example of the _callable_context_ when we looked at the simple
+calculator expression evaluator. There, we wanted to customize the evaluation
+of placeholder terminals, and delegate the handling of all other nodes to the
+_default_context_. We did that as follows:
+
+ // An evaluation context for calculator expressions that
+ // explicitly handles placeholder terminals, but defers the
+ // processing of all other nodes to the default_context.
+ struct calculator_context
+ : proto::callable_context< calculator_context const >
+ {
+ calculator_context(double d1, double d2)
+ : d1_(d1), d2_(d2)
+ {}
+
+ // Define the result type of the calculator.
+ typedef double result_type;
+
+ // Handle the placeholders:
+ double operator()(proto::tag::terminal, placeholder1) const
+ {
+ return this->d1_;
+ }
+
+ double operator()(proto::tag::terminal, placeholder2) const
+ {
+ return this->d2_;
+ }
+
+ private:
+ double d1_, d2_;
+ };
+
+In this case, we didn't specify a fall-back context. In that case,
+_callable_context_ uses the _default_context_. With the above
+`calculator_context` and a couple of appropriately defined placeholder
+terminals, we can evaluate calculator expressions, as demonstrated
+below:
+
+ struct placeholder1 {};
+ struct placeholder2 {};
+ terminal<placeholder1>::type const _1 = {{}};
+ terminal<placeholder2>::type const _2 = {{}};
+ // ...
+
+ double j = proto::eval(
+ (_2 - _1) / _2 * 100
+ , calculator_context(4, 5)
+ );
+ std::cout << "j = " << j << std::endl;
+
+The above code displays the following:
+
+[pre
+j = 20
+]
[endsect]
Modified: branches/fix-links/libs/xpressive/proto/doc/installation.qbk
==============================================================================
--- branches/fix-links/libs/xpressive/proto/doc/installation.qbk (original)
+++ branches/fix-links/libs/xpressive/proto/doc/installation.qbk 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -9,8 +9,10 @@
[heading Getting Proto]
-Currently the only way to get Proto is through SVN via the boost project on
-SourceForge.net. Just go to [@http://svn.boost.org/trac/boost/wiki/BoostSubversion]
+You can get Proto by downloading [^proto.zip] from
+[@http://www.boost-consulting.com/vault/index.php?directory=Template%20Metaprogramming]
+or by accessing Boost's SVN repository on SourceForge.net. Just go to
+[@http://svn.boost.org/trac/boost/wiki/BoostSubversion]
and follow the instructions there for anonymous SVN access.
[heading Building with Proto]
Modified: branches/fix-links/libs/xpressive/proto/doc/proto.qbk
==============================================================================
--- branches/fix-links/libs/xpressive/proto/doc/proto.qbk (original)
+++ branches/fix-links/libs/xpressive/proto/doc/proto.qbk 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -38,38 +38,39 @@
[def _spirit_fx_ [@http://spirit.sourceforge.net Spirit Parser Framework]]
[def _spirit_ [@http://spirit.sourceforge.net Spirit]]
[def _xpressive_ [@../../../libs/xpressive/doc/index.html Boost.Xpressive]]
-[def _expr_ [classref boost::proto::exprns_::expr<Tag,Args,1> `expr<>`]]
-[def _ref_ [classref boost::proto::refns_::ref_ `ref_<>`]]
-[def _unref_ [classref boost::proto::functional::unref `unref()`]]
-[def _deep_copy_ [classref boost::proto::functional::deep_copy `deep_copy()`]]
-[def _extends_ [classref boost::proto::exprns_::extends `extends<>`]]
-[def _as_expr_ [classref boost::proto::functional::as_expr `as_expr()`]]
-[def _as_arg_ [classref boost::proto::functional::as_arg `as_arg()`]]
-[def _make_expr_ [funcref boost::proto::make_expr `make_expr()`]]
-[def _unpack_expr_ [funcref boost::proto::unpack_expr `unpack_expr()`]]
-[def _matches_ [classref boost::proto::result_of::matches `matches<>`]]
-[def _or_ [classref boost::proto::control::or_ `or_<>`]]
-[def _and_ [classref boost::proto::control::and_ `and_<>`]]
-[def _if_ [classref boost::proto::control::if_ `if_<>`]]
-[def _not_ [classref boost::proto::control::not_ `not_<>`]]
-[def _exact_ [classref boost::proto::control::exact `exact<>`]]
-[def _convertible_to_ [classref boost::proto::control::convertible_to `convertible_to<>`]]
-[def _is_expr_ [classref boost::proto::result_if::is_expr `is_expr<>`]]
-[def _tag_of_ [classref boost::proto::result_if::tag_of `tag_of<>`]]
-[def _arg_ [funcref boost::proto::arg `arg()`]]
-[def _arg_c_ [funcref boost::proto::arg_c `arg_c()`]]
-[def _eval_ [classref boost::proto::functional::eval `eval()`]]
-[def _left_ [classref boost::proto::functional::left `left()`]]
-[def _right_ [classref boost::proto::functional::right `right()`]]
-[def _terminal_ [classref boost::proto::op::terminal `terminal<>`]]
-[def _unary_expr_ [classref boost::proto::op::unary_expr `unary_expr<>`]]
-[def _binary_expr_ [classref boost::proto::op::binary_expr `binary_expr<>`]]
-[def _literal_ [classref boost::proto::utility::literal `literal<>`]]
-[def _lit_ [funcref boost::proto::lit `lit()`]]
-[def _vararg_ [classref boost::proto::control::vararg `vararg<>`]]
-[def _default_context_ [classref boost::proto::context::default_context `default_context`]]
-[def _callable_context_ [classref boost::proto::context::callable_context `callable_context<>`]]
-[def _when_ [classref boost::proto::transform::when `when<>`]]
+[def _expr_ [classref boost::proto::exprns_::expr<Tag,Args,1> `expr<>`]]
+[def _ref_ [classref boost::proto::refns_::ref_ `ref_<>`]]
+[def _unref_ [classref boost::proto::functional::unref `unref()`]]
+[def _deep_copy_ [classref boost::proto::functional::deep_copy `deep_copy()`]]
+[def _extends_ [classref boost::proto::exprns_::extends `extends<>`]]
+[def _as_expr_ [funcref boost::proto::as_expr `as_expr()`]]
+[def _as_arg_ [funcref boost::proto::as_arg `as_arg()`]]
+[def _make_expr_ [funcref boost::proto::make_expr `make_expr()`]]
+[def _unpack_expr_ [funcref boost::proto::unpack_expr `unpack_expr()`]]
+[def _matches_ [classref boost::proto::result_of::matches `matches<>`]]
+[def _or_ [classref boost::proto::control::or_ `or_<>`]]
+[def _and_ [classref boost::proto::control::and_ `and_<>`]]
+[def _if_ [classref boost::proto::control::if_ `if_<>`]]
+[def _not_ [classref boost::proto::control::not_ `not_<>`]]
+[def _exact_ [classref boost::proto::control::exact `exact<>`]]
+[def _convertible_to_ [classref boost::proto::control::convertible_to `convertible_to<>`]]
+[def _is_expr_ [classref boost::proto::result_if::is_expr `is_expr<>`]]
+[def _tag_of_ [classref boost::proto::result_if::tag_of `tag_of<>`]]
+[def _arg_ [funcref boost::proto::arg `arg()`]]
+[def _arg_c_ [funcref boost::proto::arg_c `arg_c()`]]
+[def _eval_ [memberref boost::proto::eval `eval()`]]
+[def _left_ [classref boost::proto::functional::left `left()`]]
+[def _right_ [classref boost::proto::functional::right `right()`]]
+[def _terminal_ [classref boost::proto::op::terminal `terminal<>`]]
+[def _unary_expr_ [classref boost::proto::op::unary_expr `unary_expr<>`]]
+[def _binary_expr_ [classref boost::proto::op::binary_expr `binary_expr<>`]]
+[def _literal_ [classref boost::proto::utility::literal `literal<>`]]
+[def _lit_ [funcref boost::proto::lit `lit()`]]
+[def _vararg_ [classref boost::proto::control::vararg `vararg<>`]]
+[def _default_context_ [classref boost::proto::context::default_context `default_context`]]
+[def _callable_context_ [classref boost::proto::context::callable_context `callable_context<>`]]
+[def _null_context_ [classref boost::proto::context::null_context `null_context<>`]]
+[def _when_ [classref boost::proto::transform::when `when<>`]]
[include preface.qbk]
Modified: branches/fix-links/libs/xpressive/proto/doc/protodoc.xml
==============================================================================
--- branches/fix-links/libs/xpressive/proto/doc/protodoc.xml (original)
+++ branches/fix-links/libs/xpressive/proto/doc/protodoc.xml 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -54,10 +54,7 @@
<template-type-parameter name="Context"/>
<template-type-parameter name="Tag"/>
<template-nontype-parameter name="Arity"><type>long</type></template-nontype-parameter>
- </template></struct><struct name="default_context"><description><para>default_context </para></description><struct name="eval"><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="ThisContext"><default>default_context const</default></template-type-parameter>
- </template><inherit access="public">boost::proto::context::default_eval< Expr, ThisContext ></inherit><description><para>default_context::eval </para></description></struct></struct><struct-specialization name="default_eval"><template>
+ </template></struct><struct-specialization name="default_eval"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
</template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::posit</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
@@ -174,7 +171,7 @@
</template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::bitwise_xor_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::terminal</template-arg><template-arg>0</template-arg></specialization><typedef name="result_type"><type>mpl::if_< is_const < Expr >, typename <classname>proto::result_of::arg</classname>< Expr >::const_reference, typename <classname>proto::result_of::arg</classname>< Expr >::reference >::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name=""><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::terminal</template-arg><template-arg>0</template-arg></specialization><typedef name="result_type"><type>mpl::if_< is_const< Expr >, typename <classname>proto::result_of::arg</classname>< Expr >::const_reference, typename <classname>proto::result_of::arg</classname>< Expr >::reference >::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name=""><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
</template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::post_inc</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
@@ -207,7 +204,10 @@
</template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>4</template-arg></specialization><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 3 >::type >::type, Context >::type)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><paramete
r name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>5</template-arg></specialization><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 3 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 4 >::t
ype >::type, Context >::type)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/context/null.hpp"><para>Definintion of null_context<>, an evaluation context for proto::eval() that simply evaluates each child expression, doesn't combine the results at all, and returns void. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="null_eval"><template>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>5</template-arg></specialization><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 3 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 4 >::t
ype >::type, Context >::type)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct name="default_context"><description><para>default_context </para></description><struct name="eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="ThisContext"><default>default_context const</default></template-type-parameter>
+ </template><inherit access="public">boost::proto::context::default_eval< Expr, ThisContext ></inherit><description><para>default_context::eval </para></description></struct></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/context/null.hpp"><para>Definintion of null_context<>, an evaluation context for proto::eval() that simply evaluates each child expression, doesn't combine the results at all, and returns void. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="null_eval"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
<template-nontype-parameter name="Arity"><type>long</type></template-nontype-parameter>
@@ -243,19 +243,17 @@
</template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 0 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>T const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group><constructor><parameter name="depth"><paramtype>int</paramtype><default>0</default><description><para>The starting indentation depth for this node. Children nodes will be displayed at a starting depth of <computeroutput>depth+4</computeroutput>. </para></description></parameter><parameter name="sout"><paramtype>std::ostream &</paramtype><default>std::cout</default><description><para>The <computeroutput>ostream</computeroutput> to which the expression tree will be written. </para></description></parameter><description><para>
-</para></description></constructor></struct></namespace><namespace name="tag"><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::posit</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::negate</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::dereference</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::complement</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::address_of</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_not</classname></paramtype></parameter></
function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_right</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><param
eter name=""><paramtype><classname>tag::multiplies</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater</classname></paramtype></parameter></f
unction><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::not_equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_or</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *<
/type><parameter name=""><paramtype><classname>tag::bitwise_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::comma</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::mem_ptr</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left_assign</cl
assname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_right_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus_assign</classname></paramtype></parameter></fun
ction><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::subscript</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::if_else_</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::function</classname></paramtype></parameter></function></namespace><overloaded-function name="
display_expr"><signature><type>void</type><template>
+</para></description></constructor><method-group name="private member functions"/><copy-assignment><parameter name=""><paramtype><classname>display_expr</classname> const &</paramtype></parameter></copy-assignment></struct></namespace><namespace name="tag"><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::posit</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::negate</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::dereference</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::complement</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::address_of</classname></pa
ramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_not</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left</classname></paramtype></parameter></function><function name="proto_tag_name"><type>cha
r const *</type><parameter name=""><paramtype><classname>tag::shift_right</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less</classname><
/paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::not_equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_or</classname></paramtype></parameter></function><function name="proto_tag_nam
e"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::comma</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::mem_ptr</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname
>tag::assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_right_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus_assign</classname></paramt
ype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::subscript</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::if_else_</classname></paramtype></parameter></function><function name
="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::function</classname></paramtype></parameter></function></namespace><overloaded-function name="display_expr"><signature><type>void</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The Proto expression tree to pretty-print </para></description></parameter><parameter name="sout"><paramtype>std::ostream &</paramtype><description><para>The <computeroutput>ostream</computeroutput> to which the output should be written. </para></description></parameter></signature><signature><type>void</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Pretty-print a Proto expression tree. </purpose><description><para>
</para></description><notes><para>Equivalent to <computeroutput>functional::display_expr(0, sout)(expr)</computeroutput> </para></notes></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/deep_copy.hpp"><para>Replace all nodes stored by reference by nodes stored by value. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="deep_copy"><purpose>A PolymorphicFunctionObject type for deep-copying Proto expression trees. </purpose><description><para>A PolymorphicFunctionObject type for deep-copying Proto expression trees. When a tree is deep-copied, all internal nodes and most terminals held by reference are instead held by value.</para><para>
-</para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+</para></description><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::deep_copy</classname>< typename boost::remove_const < typename boost::remove_reference< Expr >::type >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::deep_copy</classname>< Expr >::type</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::deep_copy</classname>< typename boost::remove_const< typename boost::remove_reference< Expr >::type >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::deep_copy</classname>< Expr >::type</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><purpose>Deep-copies a Proto expression tree, turning all nodes and terminals held by reference into ones held by value. </purpose></method></method-group></struct></namespace><namespace name="result_of"><struct name="deep_copy"><template>
<template-type-parameter name="Expr"/>
@@ -292,18 +290,16 @@
</template><inherit access="public">boost::mpl::false_</inherit><description><para>A metafunction that returns <computeroutput>mpl::true_</computeroutput> if the type <computeroutput>T</computeroutput> is the type of a Proto domain; <computeroutput>mpl::false_</computeroutput> otherwise. If <computeroutput>T</computeroutput> inherits from <computeroutput>proto::domain<></computeroutput>, <computeroutput>is_domain<T></computeroutput> is <computeroutput>mpl::true_</computeroutput>. </para></description></struct><struct name="domain_of"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="EnableIf"/>
- </template><description><para>A metafunction that returns the domain of a given type. If <computeroutput>T</computeroutput> is a Proto expression type, it returns that expression's associated domain. If not, it returns <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="type"><type>default_domain</type></typedef></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/eval.hpp"><para>Contains the eval() expression evaluator. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="eval"><purpose>A PolymorphicFunctionObject type for evaluating a given Proto expression with a given context. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><description><para>A metafunction that returns the domain of a given type. If <computeroutput>T</computeroutput> is a Proto expression type, it returns that expression's associated domain. If not, it returns <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="type"><type>default_domain</type></typedef></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/eval.hpp"><para>Contains the eval() expression evaluator. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="eval"><purpose>A PolymorphicFunctionObject type for evaluating a given Proto expression with a given context. </purpose><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>Context)</template-arg></specialization><typedef name="type"><type><classname>proto::result_of::eval</classname>< typename remove_reference< Expr >::type, typename remove_reference< Context >::type >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>proto::result_of::eval</classname>< Expr, Context >::type</type><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>Context)</template-arg></specialization><typedef name="type"><type><classname>proto::result_of::eval</classname>< typename remove_reference< Expr >::type, typename remove_reference< Context >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>proto::result_of::eval</classname>< Expr, Context >::type</type><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter><purpose>Evaluate a given Proto expression with a given context. </purpose><description><para>
-</para></description><notes><para>This function is equivalent to <computeroutput>typename Context::template eval<Expr>()(expr, context)</computeroutput>. </para></notes></method><method name="operator()" cv="const"><type><classname>proto::result_of::eval</classname>< Expr, Context >::type</type><template>
+</para></description><returns><para><computeroutput>typename Context::template eval<Expr>()(expr, context)</computeroutput> </para></returns></method><method name="operator()" cv="const"><type><classname>proto::result_of::eval</classname>< Expr, Context >::type</type><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Context"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct></namespace><namespace name="result_of"><struct name="eval"><template>
@@ -321,23 +317,23 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv=""><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr >, typename <classname>result_of::as_arg</classname>< A >::type > > const</type><template>
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv=""><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv=""><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr > > > const</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv=""><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr > > > const</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const , const A0 >::type const</type><template>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, const A0, const A1 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const , const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -375,19 +371,19 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const , const A0 >::type const</type><template>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, const A0, const A1 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const , const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -411,19 +407,19 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const , const A0 >::type const</type><template>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, const A0, const A1 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const , const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -448,19 +444,19 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const , const A0 >::type const</type><template>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, const A0, const A1 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const , const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -486,19 +482,19 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const , const A0 >::type const</type><template>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, const A0, const A1 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const , const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -525,19 +521,19 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</classname>< A const >::type > > const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>args1</classname>< ref_< expr const > > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const , const A0 >::type const</type><template>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, const A0, const A1 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const , const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -563,7 +559,7 @@
</template><specialization><template-arg>Expr()</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop0< This ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct-specialization name="funop"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const()</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop0< Expr ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop1"><template>
+ </template><specialization><template-arg>Expr const ()</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop0< Expr ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop1"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="A0"/>
</template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>args2</classname>< ref_< Expr >, typename <classname>result_of::as_arg</classname>< A0 >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
@@ -574,7 +570,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop1< Expr, A0 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop2"><template>
+ </template><specialization><template-arg>Expr const (A0)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop1< Expr, A0 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop2"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
@@ -588,7 +584,7 @@
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0</template-arg><template-arg>A1)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop2< Expr, A0, A1 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop3"><template>
+ </template><specialization><template-arg>Expr const (A0</template-arg><template-arg>A1)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop2< Expr, A0, A1 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop3"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
@@ -605,7 +601,7 @@
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop3< Expr, A0, A1, A2 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop4"><template>
+ </template><specialization><template-arg>Expr const (A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop3< Expr, A0, A1, A2 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop4"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
@@ -625,7 +621,7 @@
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop4< Expr, A0, A1, A2, A3 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/extends.hpp"><para>Macros and a base class for defining end-user expression types </para><namespace name="boost"><namespace name="proto"><namespace name="exprns_"><struct name="is_proto_expr"><purpose>Empty type to be used as a dummy template parameter of POD expression wrappers. It allows argument-dependent lookup to find Proto's operator overloads. </purpose><description><para><computeroutput>proto::is_proto_expr</computeroutput> allows argument-dependent look
up to find Proto's operator overloads. For example:</para><para><programlisting> template<typename T, typename Dummy = proto::is_proto_expr>
+ </template><specialization><template-arg>Expr const (A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop4< Expr, A0, A1, A2, A3 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/extends.hpp"><para>Macros and a base class for defining end-user expression types </para><namespace name="boost"><namespace name="proto"><namespace name="exprns_"><struct name="is_proto_expr"><purpose>Empty type to be used as a dummy template parameter of POD expression wrappers. It allows argument-dependent lookup to find Proto's operator overloads. </purpose><description><para><computeroutput>proto::is_proto_expr</computeroutput> allows argument-dependent loo
kup to find Proto's operator overloads. For example:</para><para><programlisting> template<typename T, typename Dummy = proto::is_proto_expr>
struct my_terminal
{
BOOST_PROTO_EXTENDS(
@@ -645,9 +641,9 @@
<template-type-parameter name="Tag"/>
</template><purpose>extends<> class template for adding behaviors to a Proto expression template </purpose><struct name="result"><template>
<template-type-parameter name="Sig"/>
- </template><typedef name="type"><type>boost::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>Expr</type></typedef><typedef name="proto_domain"><type>Domain</type></typedef><typedef name="proto_derived_expr"><type>Derived</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><method-group name="public member functions"><method name="proto_base" cv=""><type>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
+ </template><typedef name="type"><type>boost::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>Expr</type></typedef><typedef name="proto_domain"><type>Domain</type></typedef><typedef name="proto_derived_expr"><type>Derived</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><method-group name="public member functions"><method name="proto_base" cv=""><type>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
+ </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A const &</paramtype></parameter></method><method name="operator()" cv="const"><type>boost::mpl::apply_wrap1< Domain, typename <classname>boost::proto::result_of::funop0</classname>< Derived const >::type >::type const</type></method><method name="operator()" cv="const"><type>boost::mpl::apply_wrap1< Domain, typename <classname>boost::proto::result_of::funop1</classname>< Derived const , const A0 >::type >::type const</type><template>
<template-type-parameter name="A0"/>
@@ -673,9 +669,9 @@
<template-type-parameter name="Domain"/>
</template><specialization><template-arg>Expr</template-arg><template-arg>Derived</template-arg><template-arg>Domain</template-arg><template-arg>tag::terminal</template-arg></specialization><purpose>extends<> class template for adding behaviors to a Proto expression template </purpose><struct name="result"><template>
<template-type-parameter name="Sig"/>
- </template><typedef name="type"><type>boost::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>Expr</type></typedef><typedef name="proto_domain"><type>Domain</type></typedef><typedef name="proto_derived_expr"><type>Derived</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><method-group name="public member functions"><method name="extends" cv=""><type/></method><method name="extends" cv=""><type/><parameter name="that"><paramtype><classname>extends</classname> const &</paramtype></parameter></method><method name="extends" cv=""><type/><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter></method><method name="proto_base" cv=""><type>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
+ </template><typedef name="type"><type>boost::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>Expr</type></typedef><typedef name="proto_domain"><type>Domain</type></typedef><typedef name="proto_derived_expr"><type>Derived</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><method-group name="public member functions"><method name="extends" cv=""><type/></method><method name="extends" cv=""><type/><parameter name="that"><paramtype><classname>extends</classname> const &</paramtype></parameter></method><method name="extends" cv=""><type/><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter></method><method name="proto_base" cv=""><type>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
+ </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A const &</paramtype></parameter></method><method name="operator[]" cv=""><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
<template-type-parameter name="A"/>
@@ -717,29 +713,20 @@
<template-type-parameter name="A"/>
</template><parameter name="a"><paramtype>A &</paramtype></parameter></copy-assignment><copy-assignment><template>
<template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter></copy-assignment><method-group name="public static functions"><method name="make" cv=""><type>static Derived const</type><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/fusion.hpp"><para>Make any Proto expression a valid Fusion sequence </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>functional::flatten</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>functional::pop_front</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>functional::reverse</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="functional"><struct name="flatten"><purpose>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. </purpose><description><para>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. For a tree with a top-most node tag of type <computeroutput>T</computeroutput>, the elements of the flattened sequence are determined by recursing into each child node with the same tag type and returning those nodes of different type. So for instance, the Proto expression tree corresponding to the expression <computeroutput>a | b | c</computeroutput> has a flattened view with elements [a, b, c], even though the tree is grouped as <computeroutput>((a | b) | c)</computeroutput>. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter></copy-assignment><method-group name="public static functions"><method name="make" cv=""><type>static Derived const</type><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/fusion.hpp"><para>Make any Proto expression a valid Fusion sequence </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="flatten"><purpose>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. </purpose><description><para>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. For a tree with a top-most node tag of type <computeroutput>T</computeroutput>, the elements of the flattened sequence are determined by recursing into each child node with the same tag type and returning those
nodes of different type. So for instance, the Proto expression tree corresponding to the expression <computeroutput>a | b | c</computeroutput> has a flattened view with elements [a, b, c], even though the tree is grouped as <computeroutput>((a | b) | c)</computeroutput>. </para></description><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
</template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
<template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="pop_front"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>pop_front(_)</computeroutput> which removes the first child from a Proto expression node. Such a transform might be used as the first argument to the <computeroutput>proto::transform::fold<></computeroutput> transform; that is, fold all but the first child. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="pop_front"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>pop_front(_)</computeroutput> which removes the first child from a Proto expression node. Such a transform might be used as the first argument to the <computeroutput>proto::transform::fold<></computeroutput> transform; that is, fold all but the first child. </para></description><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>fusion::result_of::pop_front< typename boost::remove_reference< Expr >::type const >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>fusion::result_of::pop_front< Expr const >::type</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>fusion::result_of::pop_front< typename boost::remove_reference< Expr >::type const >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>fusion::result_of::pop_front< Expr const >::type</type><template>
<template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="reverse"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>reverse(_)</computeroutput> which reverses the order of the children of a Proto expression node. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="reverse"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>reverse(_)</computeroutput> which reverses the order of the children of a Proto expression node. </para></description><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>fusion::result_of::reverse< typename boost::remove_reference< Expr >::type const >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>fusion::result_of::reverse< Expr const >::type</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>fusion::result_of::reverse< typename boost::remove_reference< Expr >::type const >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>fusion::result_of::reverse< Expr const >::type</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct></namespace><data-member name="flatten"><type><classname>functional::flatten</classname> const</type><purpose>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. </purpose><description><para><para>boost::proto::functional::flatten </para>
</para></description></data-member></namespace></namespace></header><header name="boost/xpressive/proto/generate.hpp"><para>Contains definition of generate<> class template, which end users can specialize for generating domain-specific expression wrappers. </para><namespace name="boost"><namespace name="proto"><namespace name="generatorns_"><struct name="default_generator"><purpose>A simple generator that passes an expression through unchanged. </purpose><description><para>Generators are intended for use as the first template parameter to the <computeroutput>domain<></computeroutput> class template and control if and how expressions within that domain are to be customized. The <computeroutput>default_generator</computeroutput> makes no modifications to the expressions passed to it. </para></description><struct name="apply"><template>
@@ -775,7 +762,7 @@
</para></description><returns><para>Generator::make(deep_copy(expr)) </para></returns></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/literal.hpp"><para>The literal<> terminal wrapper, and the proto::lit() function for creating literal<> wrappers. </para><namespace name="boost"><namespace name="proto"><namespace name="utility"><struct name="literal"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="Domain"/>
- </template><purpose>A simple wrapper for a terminal, provided for ease of use. </purpose><description><para>A simple wrapper for a terminal, provided for ease of use. In all cases, <computeroutput>literal<X> l(x);</computeroutput> is equivalent to <computeroutput>terminal<X>type l = {x};</computeroutput>.</para><para>The <computeroutput>Domain</computeroutput> template parameter defaults to <computeroutput>proto::default_domain</computeroutput>. </para></description><method-group name="public member functions"/><constructor><template>
+ </template><purpose>A simple wrapper for a terminal, provided for ease of use. </purpose><description><para>A simple wrapper for a terminal, provided for ease of use. In all cases, <computeroutput>literal<X> l(x);</computeroutput> is equivalent to <computeroutput>terminal<X>type l = {x};</computeroutput>.</para><para>The <computeroutput>Domain</computeroutput> template parameter defaults to <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="value_type"><type><classname>proto::result_of::arg</classname>< terminal_type >::type</type></typedef><typedef name="reference"><type><classname>proto::result_of::arg</classname>< terminal_type >::reference</type></typedef><typedef name="const_reference"><type><classname>proto::result_of::arg</classname>< terminal_type >::const_reference</type></typedef><method-group name="public member functions"><method name="get" cv=""><type>reference</type></method><method name="get" cv="const"><type>const_ref
erence</type></method></method-group><constructor><template>
<template-type-parameter name="U"/>
</template><parameter name="u"><paramtype>U &</paramtype></parameter></constructor><constructor><template>
<template-type-parameter name="U"/>
@@ -789,18 +776,10 @@
-</para></description><returns><para>literal<T &>(t) </para></returns><throws><simpara>Will not throw.</simpara></throws><notes><para>The returned value holds the argument by reference. </para></notes></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from children nodes or from a Fusion sequence of children nodes, respectively. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"/>
- </template><specialization><template-arg>functional::make_expr< Tag</template-arg><template-arg>Domain ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
+</para></description><returns><para>literal<T &>(t) </para></returns><throws><simpara>Will not throw.</simpara></throws><notes><para>The returned value holds the argument by reference. </para></notes></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from children nodes or from a Fusion sequence of children nodes, respectively. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="make_expr"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Domain"/>
- </template><specialization><template-arg>functional::unpack_expr< Tag</template-arg><template-arg>Domain ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="functional"><struct name="make_expr"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="A0"/>
</template><specialization><template-arg>This(A0)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0 >::type</type></typedef></struct-specialization><struct-specialization name="result"><template>
@@ -825,7 +804,7 @@
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="A4"/>
- </template><specialization><template-arg>This(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0, A1, A2, A3, A4 >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0 const >::type const</type><template>
+ </template><specialization><template-arg>This(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0, A1, A2, A3, A4 >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0 const >::type const</type><template>
<template-type-parameter name="A0"/>
</template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>Construct an expression node with tag type <computeroutput>Tag</computeroutput> and in the domain <computeroutput>Domain</computeroutput>. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1 >::type const</type><template>
<template-type-parameter name="A0"/>
@@ -860,7 +839,11 @@
<template-type-parameter name="Sequence"/>
<template-type-parameter name="EnableIf1"/>
<template-type-parameter name="EnableIf2"/>
- </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct name="make_expr"><template>
+ </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct-specialization name="unpack_expr"><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="Sequence"/>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Domain</template-arg><template-arg>Sequence</template-arg><template-arg>typename Domain::proto_is_domain_</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct name="make_expr"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
@@ -869,11 +852,7 @@
<template-type-parameter name="A4"/>
<template-type-parameter name="EnableIf1"/>
<template-type-parameter name="EnableIf2"/>
- </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct-specialization name="unpack_expr"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"/>
- <template-type-parameter name="Sequence"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Domain</template-arg><template-arg>Sequence</template-arg><template-arg>typename Domain::proto_is_domain_</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="make_expr"><template>
+ </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct-specialization name="make_expr"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Domain"/>
<template-type-parameter name="A0"/>
@@ -884,14 +863,14 @@
</template><specialization><template-arg>Tag</template-arg><template-arg>Domain</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>typename Domain::proto_is_domain_</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></namespace><overloaded-function name="unpack_expr"><signature><type>lazy_disable_if< is_domain< Sequence >, <classname>result_of::unpack_expr</classname>< Tag, Sequence const >>::type const</type><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Sequence"/>
- </template><parameter name="sequence"><paramtype>Sequence const &</paramtype></parameter></signature><signature><type><classname>result_of::unpack_expr</classname>< Tag, Domain, Sequence2 const >::type const</type><template>
+ </template><parameter name="sequence"><paramtype>Sequence const &</paramtype></parameter></signature><signature><type><classname>result_of::unpack_expr</classname>< Tag, Domain, Sequence2 const >::type const</type><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Domain"/>
<template-type-parameter name="Sequence2"/>
</template><parameter name="sequence2"><paramtype>Sequence2 const &</paramtype></parameter></signature><description><para>unpack_expr </para></description></overloaded-function><overloaded-function name="make_expr"><signature><type>lazy_disable_if< is_domain< A0 >, <classname>result_of::make_expr</classname>< Tag, A0 const >>::type const</type><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter></signature><signature><type><classname>result_of::make_expr</classname>< Tag, Domain, B0 const >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter></signature><signature><type><classname>result_of::make_expr</classname>< Tag, Domain, B0 const >::type const</type><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Domain"/>
<template-type-parameter name="B0"/>
@@ -943,37 +922,9 @@
<template-type-parameter name="B2"/>
<template-type-parameter name="B3"/>
<template-type-parameter name="B4"/>
- </template><parameter name="b0"><paramtype>const B0 &</paramtype></parameter><parameter name="b1"><paramtype>const B1 &</paramtype></parameter><parameter name="b2"><paramtype>const B2 &</paramtype></parameter><parameter name="b3"><paramtype>const B3 &</paramtype></parameter><parameter name="b4"><paramtype>const B4 &</paramtype></parameter></signature><description><para>make_expr </para></description></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/matches.hpp"><para>Contains definition of matches<> metafunction for determining if a given expression matches a given pattern. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="G0"/>
- <template-type-parameter name="G1"/>
- <template-type-parameter name="G2"/>
- <template-type-parameter name="G3"/>
- <template-type-parameter name="G4"/>
- <template-type-parameter name="G5"/>
- <template-type-parameter name="G6"/>
- <template-type-parameter name="G7"/>
- </template><specialization><template-arg>or_< G0</template-arg><template-arg>G1</template-arg><template-arg>G2</template-arg><template-arg>G3</template-arg><template-arg>G4</template-arg><template-arg>G5</template-arg><template-arg>G6</template-arg><template-arg>G7 ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="G0"/>
- <template-type-parameter name="G1"/>
- <template-type-parameter name="G2"/>
- <template-type-parameter name="G3"/>
- <template-type-parameter name="G4"/>
- <template-type-parameter name="G5"/>
- <template-type-parameter name="G6"/>
- <template-type-parameter name="G7"/>
- </template><specialization><template-arg>and_< G0</template-arg><template-arg>G1</template-arg><template-arg>G2</template-arg><template-arg>G3</template-arg><template-arg>G4</template-arg><template-arg>G5</template-arg><template-arg>G6</template-arg><template-arg>G7 ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Grammar"/>
- </template><specialization><template-arg>not_< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="If"/>
- <template-type-parameter name="Then"/>
- <template-type-parameter name="Else"/>
- </template><specialization><template-arg>if_< If</template-arg><template-arg>Then</template-arg><template-arg>Else ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
+ </template><parameter name="b0"><paramtype>const B0 &</paramtype></parameter><parameter name="b1"><paramtype>const B1 &</paramtype></parameter><parameter name="b2"><paramtype>const B2 &</paramtype></parameter><parameter name="b3"><paramtype>const B3 &</paramtype></parameter><parameter name="b4"><paramtype>const B4 &</paramtype></parameter></signature><description><para>make_expr </para></description></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/matches.hpp"><para>Contains definition of matches<> metafunction for determining if a given expression matches a given pattern. </para><namespace name="boost"><namespace name="proto"><namespace name="control"><struct name="not_"><template>
<template-type-parameter name="Grammar"/>
- </template><specialization><template-arg>vararg< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="control"><struct name="not_"><template>
- <template-type-parameter name="Grammar"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -982,18 +933,24 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="if_"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter><description><para>
+
+</para></description><returns><para>expr </para></returns></method></method-group></struct><struct name="if_"><template>
<template-type-parameter name="If"/>
<template-type-parameter name="Then"/>
<template-type-parameter name="Else"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="branch"><type>mpl::if_< typename when< _, If >::template <classname>result</classname>< void(Expr, State, Visitor) >::type, when< _, Then >, when< _, Else >>::type</type></typedef><typedef name="type"><type>branch::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>if_</classname></type></typedef></struct><struct name="or_"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="condition"><type>when< _, If >::template result< void(Expr, State, Visitor) >::type</type></typedef><typedef name="which"><type>mpl::if_< condition, when< _, Then >, when< _, Else >>::type</type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>if_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="or_"><template>
<template-type-parameter name="G0"/>
<template-type-parameter name="G1"/>
<template-type-parameter name="G2"/>
@@ -1002,14 +959,18 @@
<template-type-parameter name="G5"/>
<template-type-parameter name="G6"/>
<template-type-parameter name="G7"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>or_</classname></type></typedef></struct><struct name="and_"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>or_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="and_"><template>
<template-type-parameter name="G0"/>
<template-type-parameter name="G1"/>
<template-type-parameter name="G2"/>
@@ -1018,23 +979,31 @@
<template-type-parameter name="G5"/>
<template-type-parameter name="G6"/>
<template-type-parameter name="G7"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>and_</classname></type></typedef></struct><struct name="switch_"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>and_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="switch_"><template>
<template-type-parameter name="Cases"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>Cases::template case_< typename Expr::proto_tag ></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>switch_</classname></type></typedef></struct><struct name="exact"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type>Cases::template case_< typename Expr::proto_tag ></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>switch_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="exact"><template>
<template-type-parameter name="T"/>
</template></struct><struct name="convertible_to"><template>
<template-type-parameter name="T"/>
@@ -1043,9 +1012,35 @@
</template><typedef name="proto_is_vararg_"><type>void</type></typedef></struct></namespace><namespace name="result_of"><struct name="matches"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="Grammar"/>
- </template></struct></namespace><namespace name="wildcardns_"><struct name="_"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><purpose>A Boolean metafunction that evaluates whether a given expression type matches a a grammar. </purpose><description><para><computeroutput>matches<Expr,Grammar></computeroutput> inherits (indirectly) from <computeroutput>mpl::true_</computeroutput> if <computeroutput>Expr::proto_base_expr</computeroutput> matches <computeroutput>Grammar::proto_base_expr</computeroutput>, and from <computeroutput>mpl::false_</computeroutput> otherwise.</para><para>Non-terminal expressions are matched against a grammar according to the following rules:</para><para><itemizedlist>
+<listitem><para>The wildcard pattern, <computeroutput>_</computeroutput>, matches any expression. </para></listitem>
+<listitem><para>An expression <computeroutput>expr<AT, argsN<A0,A1,...An> ></computeroutput> matches a grammar <computeroutput>expr<BT, argsN<B0,B1,...Bn> ></computeroutput> if <computeroutput>BT</computeroutput> is <computeroutput>_</computeroutput> or <computeroutput>AT</computeroutput>, and if <computeroutput>Ax</computeroutput> matches <computeroutput>Bx</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>expr<AT, argsN<A0,...An,U0,...Um> ></computeroutput> matches a grammar <computeroutput>expr<BT, argsM<B0,...Bn,vararg<V> > ></computeroutput> if <computeroutput>BT</computeroutput> is <computeroutput>_</computeroutput> or <computeroutput>AT</computeroutput>, and if <computeroutput>Ax</computeroutput> matches <computeroutput>Bx</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput> and if <computeroutput>Ux</computeroutput> matches <computeroutput>V</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,m)</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>or_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches some <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>and_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches all <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>if_<T></computeroutput> if <computeroutput>when<_,T>result<void(E,int,int)>type::value</computeroutput> is <computeroutput>true</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>if_<T,U,V></computeroutput> if <computeroutput>when<_,T>result<void(E,int,int)>type::value</computeroutput> is <computeroutput>true</computeroutput> and matches <computeroutput>U</computeroutput>; or, if <computeroutput>when<_,T>result<void(E,int,int)>type::value</computeroutput> is <computeroutput>false</computeroutput> and matches <computeroutput>V</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>not_<T></computeroutput> if <computeroutput>E</computeroutput> does not match <computeroutput>T</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>switch_<C></computeroutput> if <computeroutput>E</computeroutput> matches <computeroutput>C::case_<E::proto_tag></computeroutput>.</para></listitem>
+</itemizedlist>
+A terminal expression <computeroutput>expr<tag::terminal,args0<A> ></computeroutput> matches a grammar <computeroutput>expr<BT,args0<B> ></computeroutput> if <computeroutput>BT</computeroutput> is <computeroutput>_</computeroutput> or <computeroutput>tag::terminal</computeroutput> and one of the following is true:</para><para><itemizedlist>
+<listitem><para><computeroutput>B</computeroutput> is the wildcard pattern, <computeroutput>_</computeroutput> </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>B</computeroutput> </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>B &</computeroutput> </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>B const &</computeroutput> </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>exact<A></computeroutput> </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>convertible_to<X></computeroutput> and <computeroutput>is_convertible<A,X>value</computeroutput> is <computeroutput>true</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>X[M]</computeroutput> or <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is <computeroutput>X[proto::N]</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is <computeroutput>X(&)[proto::N]</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>X[M]</computeroutput> or <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is <computeroutput>X*</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> lambda-matches <computeroutput>A</computeroutput> (see below).</para></listitem>
+</itemizedlist>
+A type <computeroutput>B</computeroutput> lambda-matches <computeroutput>A</computeroutput> one of the following is true:</para><para><itemizedlist>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>A</computeroutput> </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> is the wildcard pattern, <computeroutput>_</computeroutput> </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>T<B0,B1,...Bn></computeroutput> and <computeroutput>A</computeroutput> is <computeroutput>T<A0,A1,...An></computeroutput> and for each <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>, <computeroutput>Ax</computeroutput> and <computeroutput>Bx</computeroutput> are types such that <computeroutput>Ax</computeroutput> lambda-matches <computeroutput>Bx</computeroutput> </para></listitem>
+</itemizedlist>
+</para></description></struct></namespace><namespace name="wildcardns_"><struct name="_"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -1054,7 +1049,9 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/operators.hpp"><para>Contains all the overloaded operators that make it possible to build Proto expression trees. </para><namespace name="boost"><namespace name="proto"><struct name="is_extension"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter><description><para>
+
+</para></description><returns><para>expr </para></returns></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/operators.hpp"><para>Contains all the overloaded operators that make it possible to build Proto expression trees. </para><namespace name="boost"><namespace name="proto"><struct name="is_extension"><template>
<template-type-parameter name="T"/>
</template><inherit access="public">boost::mpl::false_</inherit></struct><namespace name="exprns_"><function name="operator+"><type><emphasis>unspecified</emphasis></type><template>
<template-type-parameter name="Arg"/>
@@ -1460,12 +1457,10 @@
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>if_else </para></description></function></namespace></namespace></namespace></header><header name="boost/xpressive/proto/proto.hpp"><para>The proto expression template compiler and supporting utilities. </para></header><header name="boost/xpressive/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="domainns_"/><namespace name="exops"/><namespace name="exprns_"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef nam
e="make_posit"><type><classname>make_expr</classname>< <classname>tag::posit</classname> ></type></typedef><typedef name="make_negate"><type><classname>make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="make_dereference"><type><classname>make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="make_complement"><type><classname>make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="make_address_of"><type><classname>make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="make_logical_not"><type><classname>make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="make_pre_inc"><type><classname>make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="make_pre_dec"><type><classname>make_expr</classname>< <classname>tag::pre_dec</classname> &g
t;</type></typedef><typedef name="make_post_inc"><type><classname>make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="make_post_dec"><type><classname>make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="make_shift_left"><type><classname>make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="make_shift_right"><type><classname>make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="make_multiplies"><type><classname>make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="make_divides"><type><classname>make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="make_modulus"><type><classname>make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="make_plus"><type><classname>make_expr</classname>< <classna
me>tag::plus</classname> ></type></typedef><typedef name="make_minus"><type><classname>make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="make_less"><type><classname>make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="make_greater"><type><classname>make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="make_less_equal"><type><classname>make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="make_greater_equal"><type><classname>make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="make_equal_to"><type><classname>make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="make_not_equal_to"><type><classname>make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="make_logical_or"><type><classname>make_
expr</classname>< <classname>tag::logical_or</classname> ></type></typedef><typedef name="make_logical_and"><type><classname>make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="make_bitwise_and"><type><classname>make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="make_bitwise_or"><type><classname>make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="make_bitwise_xor"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="make_comma"><type><classname>make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="make_mem_ptr"><type><classname>make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="make_assign"><type><classname>make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="
make_shift_left_assign"><type><classname>make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="make_shift_right_assign"><type><classname>make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="make_multiplies_assign"><type><classname>make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="make_divides_assign"><type><classname>make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="make_modulus_assign"><type><classname>make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="make_plus_assign"><type><classname>make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="make_minus_assign"><type><classname>make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="make_bitwise
_and_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="make_bitwise_or_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="make_bitwise_xor_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="make_subscript"><type><classname>make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="make_if_else"><type><classname>make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="make_function"><type><classname>make_expr</classname>< <classname>tag::function</classname> ></type></typedef></namespace><namespace name="generatorns_"/><namespace name="op"/><namespace name="refns_"/><namespace name="result_of"/><namespace name="tag"/><namespace name="transform"><struct name="callable"><typedef
name="proto_is_callable_"><type>void</type></typedef></struct><typedef name="arg0"><type><classname>arg_c</classname>< 0 ></type></typedef><typedef name="arg1"><type><classname>arg_c</classname>< 1 ></type></typedef><typedef name="arg2"><type><classname>arg_c</classname>< 2 ></type></typedef><typedef name="arg3"><type><classname>arg_c</classname>< 3 ></type></typedef><typedef name="arg4"><type><classname>arg_c</classname>< 4 ></type></typedef><typedef name="arg5"><type><classname>arg_c</classname>< 5 ></type></typedef><typedef name="arg6"><type><classname>arg_c</classname>< 6 ></type></typedef><typedef name="arg7"><type><classname>arg_c</classname>< 7 ></type></typedef><typedef name="arg8"><type><classname>arg_c</classname>< 8 ></type></typedef><typedef name="arg9"><type><classname>arg_c</classname>< 9 ></type></typedef><typedef name="arg"><type><classname>arg0</classname></type></typedef><typedef name="left"><type><classname>arg0</classname></type>
</typedef><typedef name="right"><type><classname>arg1</classname></type></typedef></namespace><namespace name="utility"/><namespace name="wildcardns_"/><typedef name="_make_terminal"><type><classname>functional::make_terminal</classname></type></typedef><typedef name="_make_posit"><type><classname>functional::make_posit</classname></type></typedef><typedef name="_make_negate"><type><classname>functional::make_negate</classname></type></typedef><typedef name="_make_dereference"><type><classname>functional::make_dereference</classname></type></typedef><typedef name="_make_complement"><type><classname>functional::make_complement</classname></type></typedef><typedef name="_make_address_of"><type><classname>functional::make_address_of</classname></type></typedef><typedef name="_make_logical_not"><type><classname>functional::make_logical_not</classname></type></typedef><typedef name="_make_pre_inc"><type><classname>functional::make_pre_inc</classname></type></typedef><typedef name="_make_pre_dec"><type><classname>
functional::make_pre_dec</classname></type></typedef><typedef name="_make_post_inc"><type><classname>functional::make_post_inc</classname></type></typedef><typedef name="_make_post_dec"><type><classname>functional::make_post_dec</classname></type></typedef><typedef name="_make_shift_left"><type><classname>functional::make_shift_left</classname></type></typedef><typedef name="_make_shift_right"><type><classname>functional::make_shift_right</classname></type></typedef><typedef name="_make_multiplies"><type><classname>functional::make_multiplies</classname></type></typedef><typedef name="_make_divides"><type><classname>functional::make_divides</classname></type></typedef><typedef name="_make_modulus"><type><classname>functional::make_modulus</classname></type></typedef><typedef name="_make_plus"><type><classname>functional::make_plus</classname></type></typedef><typedef name="_make_minus"><type><classname>functional::make_minus</classname></type></typedef><typedef name="_make_less"><type><classname>functional::
make_less</classname></type></typedef><typedef name="_make_greater"><type><classname>functional::make_greater</classname></type></typedef><typedef name="_make_less_equal"><type><classname>functional::make_less_equal</classname></type></typedef><typedef name="_make_greater_equal"><type><classname>functional::make_greater_equal</classname></type></typedef><typedef name="_make_equal_to"><type><classname>functional::make_equal_to</classname></type></typedef><typedef name="_make_not_equal_to"><type><classname>functional::make_not_equal_to</classname></type></typedef><typedef name="_make_logical_or"><type><classname>functional::make_logical_or</classname></type></typedef><typedef name="_make_logical_and"><type><classname>functional::make_logical_and</classname></type></typedef><typedef name="_make_bitwise_and"><type><classname>functional::make_bitwise_and</classname></type></typedef><typedef name="_make_bitwise_or"><type><classname>functional::make_bitwise_or</classname></type></typedef><typedef name="_make_bitwis
e_xor"><type><classname>functional::make_bitwise_xor</classname></type></typedef><typedef name="_make_comma"><type><classname>functional::make_comma</classname></type></typedef><typedef name="_make_mem_ptr"><type><classname>functional::make_mem_ptr</classname></type></typedef><typedef name="_make_assign"><type><classname>functional::make_assign</classname></type></typedef><typedef name="_make_shift_left_assign"><type><classname>functional::make_shift_left_assign</classname></type></typedef><typedef name="_make_shift_right_assign"><type><classname>functional::make_shift_right_assign</classname></type></typedef><typedef name="_make_multiplies_assign"><type><classname>functional::make_multiplies_assign</classname></type></typedef><typedef name="_make_divides_assign"><type><classname>functional::make_divides_assign</classname></type></typedef><typedef name="_make_modulus_assign"><type><classname>functional::make_modulus_assign</classname></type></typedef><typedef name="_make_plus_assign"><type><classname>functio
nal::make_plus_assign</classname></type></typedef><typedef name="_make_minus_assign"><type><classname>functional::make_minus_assign</classname></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>functional::make_bitwise_and_assign</classname></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>functional::make_bitwise_or_assign</classname></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>functional::make_bitwise_xor_assign</classname></type></typedef><typedef name="_make_subscript"><type><classname>functional::make_subscript</classname></type></typedef><typedef name="_make_if_else"><type><classname>functional::make_if_else</classname></type></typedef><typedef name="_make_function"><type><classname>functional::make_function</classname></type></typedef><typedef name="_flatten"><type><classname>functional::flatten</classname></type></typedef><typedef name="_pop_front"><type><classname>functional::pop_front</classname></type></typedef><typedef
name="_reverse"><type><classname>functional::reverse</classname></type></typedef><typedef name="_eval"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_expr"><type><classname>transform::expr</classname></type></typedef><typedef name="_state"><type><classname>transform::state</classname></type></typedef><typedef name="_visitor"><type><classname>transform::visitor</classname></type></typedef><typedef name="_arg0"><type><classname>transform::arg0</classname></type></typedef><typedef name="_arg1"><type><classname>transform::arg1</classname></type></typedef><typedef name="_arg2"><type><classname>transform::arg2</classname></type></typedef><typedef name="_arg3"><type><classname>transform::arg3</classname></type></typedef><typedef name="_arg4"><type><classname>transform::arg4</classname></type></typedef><typedef name="_arg5"><type><classname>transform::arg5</classname></type></typedef><typ
edef name="_arg6"><type><classname>transform::arg6</classname></type></typedef><typedef name="_arg7"><type><classname>transform::arg7</classname></type></typedef><typedef name="_arg8"><type><classname>transform::arg8</classname></type></typedef><typedef name="_arg9"><type><classname>transform::arg9</classname></type></typedef><typedef name="_arg"><type><classname>transform::arg</classname></type></typedef><typedef name="_left"><type><classname>transform::left</classname></type></typedef><typedef name="_right"><type><classname>transform::right</classname></type></typedef></namespace></namespace></header><header name="boost/xpressive/proto/ref.hpp"><para>Utility for storing a sub-expr by reference </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="unref"><struct name="result"><template>
- <template-type-parameter name="T"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>if_else </para></description></function></namespace></namespace></namespace></header><header name="boost/xpressive/proto/proto.hpp"><para>The proto expression template compiler and supporting utilities. </para></header><header name="boost/xpressive/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="domainns_"/><namespace name="exops"/><namespace name="exprns_"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef nam
e="make_posit"><type><classname>make_expr</classname>< <classname>tag::posit</classname> ></type></typedef><typedef name="make_negate"><type><classname>make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="make_dereference"><type><classname>make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="make_complement"><type><classname>make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="make_address_of"><type><classname>make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="make_logical_not"><type><classname>make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="make_pre_inc"><type><classname>make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="make_pre_dec"><type><classname>make_expr</classname>< <classname>tag::pre_dec</classname> &g
t;</type></typedef><typedef name="make_post_inc"><type><classname>make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="make_post_dec"><type><classname>make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="make_shift_left"><type><classname>make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="make_shift_right"><type><classname>make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="make_multiplies"><type><classname>make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="make_divides"><type><classname>make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="make_modulus"><type><classname>make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="make_plus"><type><classname>make_expr</classname>< <classna
me>tag::plus</classname> ></type></typedef><typedef name="make_minus"><type><classname>make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="make_less"><type><classname>make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="make_greater"><type><classname>make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="make_less_equal"><type><classname>make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="make_greater_equal"><type><classname>make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="make_equal_to"><type><classname>make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="make_not_equal_to"><type><classname>make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="make_logical_or"><type><classname>make_
expr</classname>< <classname>tag::logical_or</classname> ></type></typedef><typedef name="make_logical_and"><type><classname>make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="make_bitwise_and"><type><classname>make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="make_bitwise_or"><type><classname>make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="make_bitwise_xor"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="make_comma"><type><classname>make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="make_mem_ptr"><type><classname>make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="make_assign"><type><classname>make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="
make_shift_left_assign"><type><classname>make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="make_shift_right_assign"><type><classname>make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="make_multiplies_assign"><type><classname>make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="make_divides_assign"><type><classname>make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="make_modulus_assign"><type><classname>make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="make_plus_assign"><type><classname>make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="make_minus_assign"><type><classname>make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="make_bitwise
_and_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="make_bitwise_or_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="make_bitwise_xor_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="make_subscript"><type><classname>make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="make_if_else"><type><classname>make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="make_function"><type><classname>make_expr</classname>< <classname>tag::function</classname> ></type></typedef></namespace><namespace name="generatorns_"/><namespace name="op"/><namespace name="refns_"/><namespace name="result_of"/><namespace name="tag"/><namespace name="transform"><struct name="callable"><typedef
name="proto_is_callable_"><type>void</type></typedef></struct><typedef name="arg0"><type><classname>arg_c</classname>< 0 ></type></typedef><typedef name="arg1"><type><classname>arg_c</classname>< 1 ></type></typedef><typedef name="arg2"><type><classname>arg_c</classname>< 2 ></type></typedef><typedef name="arg3"><type><classname>arg_c</classname>< 3 ></type></typedef><typedef name="arg4"><type><classname>arg_c</classname>< 4 ></type></typedef><typedef name="arg5"><type><classname>arg_c</classname>< 5 ></type></typedef><typedef name="arg6"><type><classname>arg_c</classname>< 6 ></type></typedef><typedef name="arg7"><type><classname>arg_c</classname>< 7 ></type></typedef><typedef name="arg8"><type><classname>arg_c</classname>< 8 ></type></typedef><typedef name="arg9"><type><classname>arg_c</classname>< 9 ></type></typedef><typedef name="arg"><type><classname>arg0</classname></type></typedef><typedef name="left"><type><classname>arg0</classname></type>
</typedef><typedef name="right"><type><classname>arg1</classname></type></typedef></namespace><namespace name="utility"/><namespace name="wildcardns_"/><typedef name="_make_terminal"><type><classname>functional::make_terminal</classname></type></typedef><typedef name="_make_posit"><type><classname>functional::make_posit</classname></type></typedef><typedef name="_make_negate"><type><classname>functional::make_negate</classname></type></typedef><typedef name="_make_dereference"><type><classname>functional::make_dereference</classname></type></typedef><typedef name="_make_complement"><type><classname>functional::make_complement</classname></type></typedef><typedef name="_make_address_of"><type><classname>functional::make_address_of</classname></type></typedef><typedef name="_make_logical_not"><type><classname>functional::make_logical_not</classname></type></typedef><typedef name="_make_pre_inc"><type><classname>functional::make_pre_inc</classname></type></typedef><typedef name="_make_pre_dec"><type><classname>
functional::make_pre_dec</classname></type></typedef><typedef name="_make_post_inc"><type><classname>functional::make_post_inc</classname></type></typedef><typedef name="_make_post_dec"><type><classname>functional::make_post_dec</classname></type></typedef><typedef name="_make_shift_left"><type><classname>functional::make_shift_left</classname></type></typedef><typedef name="_make_shift_right"><type><classname>functional::make_shift_right</classname></type></typedef><typedef name="_make_multiplies"><type><classname>functional::make_multiplies</classname></type></typedef><typedef name="_make_divides"><type><classname>functional::make_divides</classname></type></typedef><typedef name="_make_modulus"><type><classname>functional::make_modulus</classname></type></typedef><typedef name="_make_plus"><type><classname>functional::make_plus</classname></type></typedef><typedef name="_make_minus"><type><classname>functional::make_minus</classname></type></typedef><typedef name="_make_less"><type><classname>functional::
make_less</classname></type></typedef><typedef name="_make_greater"><type><classname>functional::make_greater</classname></type></typedef><typedef name="_make_less_equal"><type><classname>functional::make_less_equal</classname></type></typedef><typedef name="_make_greater_equal"><type><classname>functional::make_greater_equal</classname></type></typedef><typedef name="_make_equal_to"><type><classname>functional::make_equal_to</classname></type></typedef><typedef name="_make_not_equal_to"><type><classname>functional::make_not_equal_to</classname></type></typedef><typedef name="_make_logical_or"><type><classname>functional::make_logical_or</classname></type></typedef><typedef name="_make_logical_and"><type><classname>functional::make_logical_and</classname></type></typedef><typedef name="_make_bitwise_and"><type><classname>functional::make_bitwise_and</classname></type></typedef><typedef name="_make_bitwise_or"><type><classname>functional::make_bitwise_or</classname></type></typedef><typedef name="_make_bitwis
e_xor"><type><classname>functional::make_bitwise_xor</classname></type></typedef><typedef name="_make_comma"><type><classname>functional::make_comma</classname></type></typedef><typedef name="_make_mem_ptr"><type><classname>functional::make_mem_ptr</classname></type></typedef><typedef name="_make_assign"><type><classname>functional::make_assign</classname></type></typedef><typedef name="_make_shift_left_assign"><type><classname>functional::make_shift_left_assign</classname></type></typedef><typedef name="_make_shift_right_assign"><type><classname>functional::make_shift_right_assign</classname></type></typedef><typedef name="_make_multiplies_assign"><type><classname>functional::make_multiplies_assign</classname></type></typedef><typedef name="_make_divides_assign"><type><classname>functional::make_divides_assign</classname></type></typedef><typedef name="_make_modulus_assign"><type><classname>functional::make_modulus_assign</classname></type></typedef><typedef name="_make_plus_assign"><type><classname>functio
nal::make_plus_assign</classname></type></typedef><typedef name="_make_minus_assign"><type><classname>functional::make_minus_assign</classname></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>functional::make_bitwise_and_assign</classname></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>functional::make_bitwise_or_assign</classname></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>functional::make_bitwise_xor_assign</classname></type></typedef><typedef name="_make_subscript"><type><classname>functional::make_subscript</classname></type></typedef><typedef name="_make_if_else"><type><classname>functional::make_if_else</classname></type></typedef><typedef name="_make_function"><type><classname>functional::make_function</classname></type></typedef><typedef name="_flatten"><type><classname>functional::flatten</classname></type></typedef><typedef name="_pop_front"><type><classname>functional::pop_front</classname></type></typedef><typedef
name="_reverse"><type><classname>functional::reverse</classname></type></typedef><typedef name="_eval"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_expr"><type><classname>transform::expr</classname></type></typedef><typedef name="_state"><type><classname>transform::state</classname></type></typedef><typedef name="_visitor"><type><classname>transform::visitor</classname></type></typedef><typedef name="_arg0"><type><classname>transform::arg0</classname></type></typedef><typedef name="_arg1"><type><classname>transform::arg1</classname></type></typedef><typedef name="_arg2"><type><classname>transform::arg2</classname></type></typedef><typedef name="_arg3"><type><classname>transform::arg3</classname></type></typedef><typedef name="_arg4"><type><classname>transform::arg4</classname></type></typedef><typedef name="_arg5"><type><classname>transform::arg5</classname></type></typedef><typ
edef name="_arg6"><type><classname>transform::arg6</classname></type></typedef><typedef name="_arg7"><type><classname>transform::arg7</classname></type></typedef><typedef name="_arg8"><type><classname>transform::arg8</classname></type></typedef><typedef name="_arg9"><type><classname>transform::arg9</classname></type></typedef><typedef name="_arg"><type><classname>transform::arg</classname></type></typedef><typedef name="_left"><type><classname>transform::left</classname></type></typedef><typedef name="_right"><type><classname>transform::right</classname></type></typedef></namespace></namespace></header><header name="boost/xpressive/proto/ref.hpp"><para>Utility for storing a sub-expr by reference </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="unref"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="T"/>
- </template><specialization><template-arg>This(T)</template-arg></specialization><inherit access="public">boost::proto::result_of::unref< T ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>T &</type><template>
+ </template><specialization><template-arg>This(T)</template-arg></specialization><inherit access="public">boost::proto::result_of::unref< boost::remove_const< boost::remove_reference< T >::type >::type ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>T &</type><template>
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>T &</paramtype></parameter></method><method name="operator()" cv="const"><type>T const &</type><template>
<template-type-parameter name="T"/>
@@ -1475,7 +1470,7 @@
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>ref_< T > const &</paramtype></parameter></method></method-group></struct></namespace><namespace name="refns_"><struct name="ref_"><template>
<template-type-parameter name="Expr"/>
- </template><typedef name="proto_base_expr"><type>Expr::proto_base_expr</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_domain"><type>Expr::proto_domain</type></typedef><typedef name="proto_is_ref_"><type>void</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>Expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><typedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><data-member name="expr"><type>Expr &</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>mpl::i
f_< is_const < Expr >, proto_base_expr const &, proto_base_expr & >::type</type></method></method-group><method-group name="public static functions"><method name="make" cv=""><type>static <classname>ref_</classname>< Expr ></type><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method></method-group></struct><struct-specialization name="ref_"><template>
+ </template><typedef name="proto_base_expr"><type>Expr::proto_base_expr</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_domain"><type>Expr::proto_domain</type></typedef><typedef name="proto_is_ref_"><type>void</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>Expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><typedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><data-member name="expr"><type>Expr &</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>mpl::i
f_< is_const< Expr >, proto_base_expr const &, proto_base_expr & >::type</type></method></method-group><method-group name="public static functions"><method name="make" cv=""><type>static <classname>ref_</classname>< Expr ></type><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method></method-group></struct><struct-specialization name="ref_"><template>
<template-type-parameter name="Expr"/>
</template><specialization><template-arg>ref_< Expr ></template-arg></specialization></struct-specialization></namespace><namespace name="result_of"><struct name="unref"><template>
<template-type-parameter name="T"/>
@@ -1491,17 +1486,13 @@
<template-type-parameter name="T"/>
</template></struct><struct name="is_aggregate"><template>
<template-type-parameter name="T"/>
- </template><description><para>is_aggregate </para></description></struct><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>proto::_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>proto::callable</template-arg></specialization><inherit access="public">boost::mpl::false_</inherit></struct-specialization><struct-specialization name="is_aggregate"><template>
+ </template><description><para>is_aggregate </para></description></struct><struct-specialization name="is_aggregate"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Args"/>
<template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
</template><specialization><template-arg>proto::expr< Tag</template-arg><template-arg>Args</template-arg><template-arg>N ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="functional"><struct name="as_expr"><template>
<template-type-parameter name="Domain"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="T"/>
</template><specialization><template-arg>This(T)</template-arg></specialization><inherit access="public">boost::proto::result_of::as_expr< remove_reference< T >::type, Domain ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::as_expr</classname>< T, Domain >::result_type</type><template>
@@ -1510,9 +1501,7 @@
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct><struct name="as_arg"><template>
<template-type-parameter name="Domain"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="T"/>
</template><specialization><template-arg>This(T)</template-arg></specialization><inherit access="public">boost::proto::result_of::as_arg< remove_reference< T >::type, Domain ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::as_arg</classname>< T, Domain >::type</type><template>
@@ -1521,9 +1510,7 @@
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct><struct name="arg_c"><template>
<template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
</template><specialization><template-arg>This(Expr)</template-arg></specialization></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result_of::arg_c< Expr, N >::reference</type><template>
@@ -1532,38 +1519,30 @@
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="arg"><template>
<template-type-parameter name="N"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::arg< boost::remove_const < boost::remove_reference< Expr >::type >::type, N ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::arg</classname>< Expr, N >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::arg< boost::remove_const< boost::remove_reference< Expr >::type >::type, N ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::arg</classname>< Expr, N >::reference</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method><method name="operator()" cv="const"><type><classname>result_of::arg</classname>< Expr, N >::const_reference</type><template>
<template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="left"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="left"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::left< boost::remove_const < boost::remove_reference< Expr >::type >::type ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::left< boost::remove_const< boost::remove_reference< Expr >::type >::type ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::reference</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::const_reference</type><template>
<template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="right"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="right"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::right< Expr ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::right< boost::remove_const< boost::remove_reference< Expr >::type >::type ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::reference</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::const_reference</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct></namespace><namespace name="op"><struct name="terminal"><template>
<template-type-parameter name="T"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -1747,10 +1726,14 @@
</template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>void</template-arg></specialization><typedef name="proto_is_callable_"><type>int</type></typedef><typedef name="type"><type>proto::expr< Tag, <classname>args5</classname>< A0, A1, A2, A3, A4 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arg0"><type>A0</type></typedef><typedef name="proto_arg1"><type>A1</type></typedef><typedef name="proto_arg2"><type>A2</type></typedef><typedef name="proto_arg3"><type>A3</type></typedef><typedef name="proto_arg4"><type>A4</type></typedef></struct-specialization></namespace><namespace name="result_of"><struct name="is_ref"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="EnableIf"/>
- </template><inherit access="public">boost::mpl::false_</inherit></struct><struct name="is_expr"><template>
+ </template><inherit access="public">boost::mpl::false_</inherit></struct><struct-specialization name="is_ref"><template>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_ref_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct name="is_expr"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="EnableIf"/>
- </template><inherit access="public">boost::mpl::false_</inherit></struct><struct name="tag_of"><template>
+ </template><inherit access="public">boost::mpl::false_</inherit></struct><struct-specialization name="is_expr"><template>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct name="tag_of"><template>
<template-type-parameter name="Expr"/>
</template><typedef name="type"><type>Expr::proto_tag</type></typedef></struct><struct name="as_expr"><template>
<template-type-parameter name="T"/>
@@ -1758,13 +1741,23 @@
<template-type-parameter name="EnableIf"/>
</template><typedef name="proto_arg0"><type>mpl::eval_if< mpl::or_< boost::is_array< T >, is_function< T > >, add_reference< T >, remove_cv< T >>::type</type></typedef><typedef name="expr_type"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>args0</classname>< proto_arg0 > ></type></typedef><typedef name="type"><type>Domain::template apply< expr_type >::type</type></typedef><typedef name="result_type"><type>type const</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static result_type</type><template>
<template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct name="as_arg"><template>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct-specialization name="as_expr"><template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Domain"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><typedef name="type"><type>T::proto_derived_expr</type></typedef><typedef name="result_type"><type>T &</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static result_type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization><struct name="as_arg"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="Domain"/>
<template-type-parameter name="EnableIf"/>
</template><typedef name="expr_type"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>args0</classname>< T & > ></type></typedef><typedef name="type"><type>Domain::template apply< expr_type >::type</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type</type><template>
<template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct name="arg"><template>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct-specialization name="as_arg"><template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Domain"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><typedef name="type"><type>ref_< T ></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization><struct name="arg"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="N"/>
</template></struct><struct name="left"><template>
@@ -1795,21 +1788,7 @@
<template-type-parameter name="Expr"/>
</template><specialization><template-arg>Expr</template-arg><template-arg>5</template-arg></specialization><typedef name="wrapped_type"><type>Expr::proto_arg5</type></typedef><typedef name="type"><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="arg_c"><template>
<template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr const</template-arg><template-arg>5</template-arg></specialization><inherit access="public">boost::proto::result_of::arg_c< Expr, 5 ></inherit></struct-specialization><struct-specialization name="is_ref"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_ref_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_expr"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="as_expr"><template>
- <template-type-parameter name="T"/>
- <template-type-parameter name="Domain"/>
- </template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><typedef name="type"><type>T::proto_derived_expr</type></typedef><typedef name="result_type"><type>T &</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static result_type</type><template>
- <template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="as_arg"><template>
- <template-type-parameter name="T"/>
- <template-type-parameter name="Domain"/>
- </template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><typedef name="type"><type>ref_< T ></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type</type><template>
- <template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization></namespace><data-member name="left"><type><classname>functional::left</classname> const</type></data-member><data-member name="right"><type><classname>functional::right</classname> const</type></data-member><function name="implicit_expr"><type><emphasis>unspecified</emphasis></type><template>
+ </template><specialization><template-arg>Expr const</template-arg><template-arg>5</template-arg></specialization><inherit access="public">boost::proto::result_of::arg_c< Expr, 5 ></inherit></struct-specialization></namespace><data-member name="left"><type><classname>functional::left</classname> const</type></data-member><data-member name="right"><type><classname>functional::right</classname> const</type></data-member><function name="implicit_expr"><type><emphasis>unspecified</emphasis></type><template>
<template-type-parameter name="A0"/>
</template><parameter name="a0"><paramtype>A0 &</paramtype></parameter></function><function name="implicit_expr"><type><emphasis>unspecified</emphasis></type><template>
<template-type-parameter name="A0"/>
@@ -1831,17 +1810,17 @@
<template-type-parameter name="A4"/>
</template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter><parameter name="a3"><paramtype>A3 &</paramtype></parameter><parameter name="a4"><paramtype>A4 &</paramtype></parameter></function><overloaded-function name="as_expr"><signature><type><classname>result_of::as_expr</classname>< T >::result_type</type><template>
<template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_expr</classname>< T const >::result_type</type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_expr</classname>< T const >::result_type</type><template>
<template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_expr </para></description></overloaded-function><overloaded-function name="as_arg"><signature><type><classname>result_of::as_arg</classname>< T >::type</type><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_expr</para><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></overloaded-function><overloaded-function name="as_arg"><signature><type><classname>result_of::as_arg</classname>< T >::type</type><template>
<template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_arg</classname>< T const >::type</type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_arg</classname>< T const >::type</type><template>
<template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_arg </para></description></overloaded-function><overloaded-function name="arg"><signature><type><classname>result_of::unref</classname>< typename Expr::proto_base_expr::proto_arg0 >::reference</type><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_arg</para><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></overloaded-function><overloaded-function name="arg"><signature><type><classname>result_of::unref</classname>< typename Expr::proto_base_expr::proto_arg0 >::reference</type><template>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></signature><signature><type><classname>result_of::unref</classname>< typename Expr::proto_base_expr::proto_arg0 >::const_reference</type><template>
<template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><description><para>arg </para></description></overloaded-function><overloaded-function name="arg_c"><signature><type>result_of::arg_c< Expr, N >::reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><description><para>arg</para><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></overloaded-function><overloaded-function name="arg_c"><signature><type>result_of::arg_c< Expr, N >::reference</type><template>
<template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></signature><signature><type>result_of::arg_c< Expr, N >::const_reference</type><template>
@@ -1849,17 +1828,7 @@
<template-type-parameter name="Expr"/>
</template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><description><para>arg_c </para></description></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/transform.hpp"><para>Includes all the transforms in the transform/ sub-directory. </para></header><header name="boost/xpressive/proto/transform/arg.hpp"><para>Contains definition of the argN transforms. </para><namespace name="boost"><namespace name="proto"><struct name="_arg_c"><template>
<template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><inherit access="public">boost::proto::transform::arg_c< I ></inherit></struct><struct-specialization name="is_callable"><template>
- <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><specialization><template-arg>_arg_c< I ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::expr</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::state</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::visitor</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><specialization><template-arg>transform::arg_c< I ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::_ref</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="expr"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><inherit access="public">boost::proto::transform::arg_c< I ></inherit></struct><namespace name="transform"><struct name="expr"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -1868,9 +1837,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="state"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="state"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -1879,9 +1846,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name="state_"><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="visitor"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name="state_"><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="visitor"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -1892,9 +1857,7 @@
<template-type-parameter name="Visitor"/>
</template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name="visitor_"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="arg_c"><template>
<template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
@@ -1903,336 +1866,362 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="_ref"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="_ref"><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="T"/>
</template><specialization><template-arg>This(T &)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T ></type></typedef></struct-specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="T"/>
- </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T const ></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>boost::reference_wrapper< T ></type><template>
+ </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T const ></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>boost::reference_wrapper< T ></type><template>
<template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype></parameter></method><method name="operator()" cv="const"><type>boost::reference_wrapper< T const ></type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype></parameter></method><method name="operator()" cv="const"><type>boost::reference_wrapper< T const ></type><template>
<template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/bind.hpp"><para>Contains definition of the bind<> transform. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/bind.hpp"><para>Contains definition of the bind<> transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="bind"><template>
<template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::bind< Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="bind"><template>
- <template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< <classname>Fun</classname> >::template <classname>result</classname>< void(Expr, State, Visitor) >::type ></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< <classname>Fun</classname> >::template result< void(Expr, State, Visitor) >::type ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct-specialization name="bind"><template>
<template-type-parameter name="Return"/>
- </template><specialization><template-arg>Return()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return()</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type() ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type() ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
- </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="A4"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3, A4) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::call< Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3, A4) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="call"><template>
<template-type-parameter name="Fun"/>
</template><inherit access="public">Fun</inherit><typedef name="proto_is_callable_"><type>void</type></typedef></struct><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
- </template><specialization><template-arg>Fun()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun()</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
<template-type-parameter name="Arg0"/>
- </template><specialization><template-arg>Fun(Arg0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(Arg0)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
<template-type-parameter name="Arg0"/>
<template-type-parameter name="Arg1"/>
- </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
<template-type-parameter name="Arg0"/>
<template-type-parameter name="Arg1"/>
<template-type-parameter name="Arg2"/>
- </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1</template-arg><template-arg>Arg2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1</template-arg><template-arg>Arg2)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, Arg0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg2 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, Arg0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg2 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
- </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="A4"/>
- </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A4 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold.hpp"><para>Contains definition of the fold<> and rever
se_fold<> transforms. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::fold< Sequence</template-arg><template-arg>State</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::reverse_fold< Sequence</template-arg><template-arg>State</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="fold"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A4 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold.hpp"><para>Contains definition of the fold<> and reverse_fold<> transforms.</para><para>Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="fold"><template>
<template-type-parameter name="Sequence"/>
<template-type-parameter name="State0"/>
<template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="sequence"><type><classname>when</classname>< _, Sequence >::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct><struct name="reverse_fold"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="sequence"><type><classname>when</classname>< _, Sequence >::template result< void(Expr, State, Visitor) >::type</type></typedef><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="reverse_fold"><template>
<template-type-parameter name="Sequence"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Fun"/>
</template><inherit access="public">boost::proto::transform::fold< Sequence, State0, Fun ></inherit></struct><struct-specialization name="fold"><template>
<template-type-parameter name="State0"/>
<template-type-parameter name="Fun"/>
- </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="reverse_fold"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="reverse_fold"><template>
<template-type-parameter name="State0"/>
<template-type-parameter name="Fun"/>
- </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold_tree.hpp"><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State0"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::fold_tree< Sequence</template-arg><template-arg>State0</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State0"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::reverse_fold_tree< Sequence</template-arg><template-arg>State0</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="fold_tree"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold_tree.hpp"><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="fold_tree"><template>
<template-type-parameter name="Sequence"/>
<template-type-parameter name="State0"/>
<template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct><struct name="reverse_fold_tree"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="reverse_fold_tree"><template>
<template-type-parameter name="Sequence"/>
<template-type-parameter name="State0"/>
<template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/make.hpp"><para>Contains definition of the make<> transform. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::make< Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/make.hpp"><para>Contains definition of the make<> transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="make"><template>
<template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct-specialization name="make"><template>
<template-type-parameter name="Return"/>
- </template><specialization><template-arg>Return()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return()</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
- </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="A4"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/pass_through.hpp"><para>TODO </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Grammar"/>
- </template><specialization><template-arg>transform::pass_through< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="pass_through"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/pass_through.hpp"><para>TODO </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="pass_through"><template>
<template-type-parameter name="Grammar"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/when.hpp"><para>Definition of when transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/when.hpp"><para>Definition of when transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Fun"/>
</template><inherit access="public">Fun</inherit><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct><struct-specialization name="when"><template>
@@ -2243,64 +2232,74 @@
</template><inherit access="public">boost::proto::transform::when< _, Fun ></inherit></struct><struct-specialization name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Return"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return()</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return() >, <classname>make</classname>< Return() > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return() >, <classname>make</classname>< Return() > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0) >, <classname>make</classname>< Return(A0) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0) >, <classname>make</classname>< Return(A0) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1) >, <classname>make</classname>< Return(A0, A1) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1) >, <classname>make</classname>< Return(A0, A1) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2) >, <classname>make</classname>< Return(A0, A1, A2) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2) >, <classname>make</classname>< Return(A0, A1, A2) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3) >, <classname>make</classname>< Return(A0, A1, A2, A3) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3) >, <classname>make</classname>< Return(A0, A1, A2, A3) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Return"/>
<template-type-parameter name="A0"/>
@@ -2308,11 +2307,13 @@
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="A4"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3, A4) >, <classname>make</classname>< Return(A0, A1, A2, A3, A4) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization></namespace></namespace></namespace></header></library-reference>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3, A4) >, <classname>make</classname>< Return(A0, A1, A2, A3, A4) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization></namespace></namespace></namespace></header></library-reference>
Modified: branches/fix-links/libs/xpressive/proto/doc/transforms.qbk
==============================================================================
--- branches/fix-links/libs/xpressive/proto/doc/transforms.qbk (original)
+++ branches/fix-links/libs/xpressive/proto/doc/transforms.qbk 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -457,6 +457,196 @@
[endsect]
+[section:if [^if_<>]]
+
+ namespace boost { namespace proto
+ {
+ namespace control
+ {
+ template<
+ typename If
+ , typename Then = _
+ , typename Else = not_<_>
+ >
+ struct if_;
+ }
+
+ using control::if_;
+ }}
+
+We've already seen the _if_ template in the context of grammars, but
+_if_ can also be used as a transform. It can be used to conditionally
+apply one transform or another based on some condition. The three
+template parameters are Proto transforms. The result of applying the
+first transform should be a compile-time Boolean. If it is true, then
+the first transform is applied. The second is applied otherwise.
+
+[table
+ [ [Expression]
+ [Returns]
+ ]
+ [ [``control::if_<If, Then, Else>
+ ::result<void(Expr, State, Visitor)>::type``]
+ [``typedef
+ mpl::if_<
+ when<_, If>::result<void(Expr, State, Visitor)>::type
+ , when<_, Then>
+ , when<_, Else>
+ >::type
+branch;
+
+typedef branch::result<void(Expr, State, Visitor)>::type type;``]
+ ]
+ [ [`control::if_<If, Then, Else>()(expr, state, visitor)`]
+ [``typedef ... branch; // Same as above
+branch()(expr, state, visitor);``]
+ ]
+]
+
+Example:
+
+ // Match a terminal. If size of the terminal
+ // argument is less than or equal to 4, make
+ // a new terminal that stores the argument by
+ // value. Otherwise, store the argument by
+ // reference.
+ struct ByValOrRef
+ : when<
+ terminal<_>
+ , if_<
+ mpl::less_equal<
+ mpl::sizeof_<_arg>
+ , mpl::size_t<4>
+ >()
+ , _make_terminal(_arg)
+ , _make_terminal(_ref(_arg))
+ >
+ >
+ {};
+
+[endsect]
+
+[section:and_or_not [^and_<>], [^or_<>], and [^not_<>]]
+
+ namespace boost { namespace proto
+ {
+ namespace control
+ {
+ template<typename... T>
+ struct and_;
+
+ template<typename... T>
+ struct or_;
+
+ template<typename T>
+ struct not_;
+ }
+
+ using control::and_;
+ using control::or_;
+ using control::not_;
+ }}
+
+As with _if_, the grammar elements _and_, _or_, and _not_ can
+also be used as transforms. At a high level, here is what the
+transforms do:
+
+[variablelist
+[ [`and_<T0,T1,...,Tn>`]
+ [Apply the transform `Tn`.] ]
+[ [`or_<T0,T1,...,Tn>`]
+ [Apply the transform `Tx` where `x` is the lowest number
+ such that `matches<Expr,Tx>::value` is `true`.] ]
+[ [`not_<T>`] [Return the current expression unchanged.] ]
+]
+
+The following table specifies the behaviors described above more
+precisely.
+
+[table
+ [ [Expression]
+ [Returns]
+ ]
+ [ [``control::and_<A,B,C>
+ ::result<void(Expr, State, Visitor)>::type``]
+ [`C::result<void(Expr, State, Visitor)>::type`]
+ ]
+ [ [`control::and_<A,B,C>()(expr, state, visitor)`]
+ [`C()(expr, state, visitor)`]
+ ]
+ [ [``control::or_<A,B,C>
+ ::result<void(Expr, State, Visitor)>::type``]
+ [``typedef mpl::if_<
+ matches<Expr, A>
+ , A
+ , mpl::if_<
+ matches<Expr, B>
+ , B
+ , C
+ >::type
+>::type which;
+
+typedef which::result<void(Expr, State, Visitor)>::type type;``]
+ ]
+ [ [`control::or_<A,B,C>()(expr, state, visitor)`]
+ [``typedef ... which; // Same as above
+which()(expr, state, visitor);``]
+ ]
+ [ [``control::not_<A>
+ ::result<void(Expr, State, Visitor)>::type``]
+ [`Expr`]
+ ]
+ [ [`control::not_<A>()(expr, state, visitor)`]
+ [`expr`]
+ ]
+]
+
+Example:
+
+ // A transform that matches any expression and
+ // unwraps any reference_wrapped terminals it
+ // finds.
+ struct UnwrapReference
+ : or_<
+ // Pass through terminals that are not
+ // reference_wrappers unchanged:
+ and_<
+ terminal<_>
+ , not_<if_<is_reference_wrapper<_arg>()> >
+ >
+ // For other terminals (i.e., reference_wrapper
+ // terminals), unwrap the reference:
+ , when<
+ terminal<_>
+ , terminal<unwrap_reference<_arg> >(_arg)
+ >
+ // Otherwise, match non-terminals and
+ // recurse.
+ , when<
+ nary_expr<_, vararg<UnwrapReference> >
+ >
+ >
+ {};
+
+The above transform serves to illustrate the behaviors of the _and_,
+_or_, and _not_ transforms, but it is admittedly contrived. The
+transform is more easily written as follows:
+
+ // Functionally identical to the UnwrapReference
+ // transform above:
+ struct UnwrapReference
+ : or_<
+ when<
+ terminal<reference_wrapper<_> >
+ , terminal<unwrap_reference<_arg> >(_arg)
+ >
+ , terminal<_>
+ , nary_expr<_, vararg<UnwrapReference> >
+ >
+ {};
+
+[endsect]
+
[section:call [^call<>]]
namespace boost { namespace proto
@@ -1065,7 +1255,7 @@
// Function call operator that actually
// executes the transform.
template<typename Expr, typename State, typename Visitor>
- typename proto::result_of::arg_c<Expr, I>::type
+ typename proto::result_of::arg_c<Expr, I>::const_reference
operator ()(Expr const &expr, State const &, Visitor &) const
{
return proto::arg_c<I>(expr);
Modified: branches/fix-links/libs/xpressive/proto/test/toy_spirit2.cpp
==============================================================================
--- branches/fix-links/libs/xpressive/proto/test/toy_spirit2.cpp (original)
+++ branches/fix-links/libs/xpressive/proto/test/toy_spirit2.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -260,69 +260,81 @@
// Globals
NoCase::type const no_case = {{}};
- // Parser
- template<typename Iterator, typename Derived>
- struct with_reset
+ template<typename Iterator>
+ struct parser;
+
+ template<typename Iterator>
+ struct fold_alternate
{
- with_reset(Iterator begin, Iterator end)
- : first(begin), second(end)
+ parser<Iterator> const &parse;
+
+ explicit fold_alternate(parser<Iterator> const &p)
+ : parse(p)
{}
template<typename T>
bool operator ()(T const &t) const
{
- Iterator tmp = this->first;
- if((*static_cast<Derived const *>(this))(t))
+ Iterator tmp = this->parse.first;
+ if(this->parse(t))
return true;
- this->first = tmp;
+ this->parse.first = tmp;
return false;
}
-
- bool done() const
- {
- return this->first == this->second;
- }
-
- mutable Iterator first;
- Iterator second;
};
template<typename Iterator>
- struct parser
- : spirit2::with_reset<Iterator, parser<Iterator> >
+ struct fold_sequence
{
- typedef spirit2::with_reset<Iterator, parser<Iterator> > with_reset;
+ parser<Iterator> const &parse;
- parser(Iterator begin, Iterator end)
- : with_reset(begin, end)
+ explicit fold_sequence(parser<Iterator> const &p)
+ : parse(p)
{}
#if BOOST_VERSION < 103500
- template<typename, typename> // used by fusion::fold
+ template<typename, typename>
struct apply
{
typedef bool type;
};
#else
- typedef bool result_type; // used by fusion::fold
+ typedef bool result_type;
#endif
template<typename T>
- bool operator ()(T const &t, bool success) const // used by fusion::fold
+ bool operator ()(T const &t, bool success) const
+ {
+ return success && this->parse(t);
+ }
+ };
+
+ template<typename Iterator>
+ struct parser
+ {
+ mutable Iterator first;
+ Iterator second;
+
+ parser(Iterator begin, Iterator end)
+ : first(begin)
+ , second(end)
+ {}
+
+ bool done() const
{
- return success && (*this)(t);
+ return this->first == this->second;
}
template<typename List>
bool operator ()(alternate<List> const &alternates) const
{
- return fusion::any(alternates.elems, *static_cast<with_reset const *>(this));
+ return fusion::any(alternates.elems, fold_alternate<Iterator>(*this));
}
template<typename List>
bool operator ()(sequence<List> const &sequence) const
{
- return fusion::fold(sequence.elems, true, *this);
+ return fusion::fold(sequence.elems, true, fold_sequence<Iterator>(*this));
}
bool operator ()(char_tag ch) const
@@ -442,6 +454,19 @@
, hello.end()
)
);
+
+ std::string nest_alt_input("abd");
+ BOOST_CHECK(
+ boost::spirit2::parse(
+ char_('a')
+ >> ( char_('b')
+ | char_('c')
+ )
+ >> char_('d')
+ , nest_alt_input.begin()
+ , nest_alt_input.end()
+ )
+ );
}
using namespace boost::unit_test;
Modified: branches/fix-links/libs/xpressive/test/test_symbols.cpp
==============================================================================
--- branches/fix-links/libs/xpressive/test/test_symbols.cpp (original)
+++ branches/fix-links/libs/xpressive/test/test_symbols.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -61,7 +61,7 @@
map1["foobazbaz"] = "5";
sregex rx = (a1=map1)[ xp::ref(result) = a1 ]
- >> *((a1=map1)[ xp::ref(result) += ',', xp::ref(result) += a1 ]);
+ >> *((a1=map1)[ xp::ref(result) += ',', xp::ref(result) += a1 ]);
if(!regex_match(str, rx))
{
Modified: branches/fix-links/libs/xpressive/test/test_typeof2.cpp
==============================================================================
--- branches/fix-links/libs/xpressive/test/test_typeof2.cpp (original)
+++ branches/fix-links/libs/xpressive/test/test_typeof2.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -102,7 +102,7 @@
std::map<std::string,std::string> map10;
TYPEOF_TEST((a1=map10)[ xp::ref(result) = a1 ] >> *(' ' >> (a1=map10)[ xp::ref(result) += ',' + a1 ]));
TYPEOF_TEST((a1=map10)[ xp::ref(result) = a1 ]
- >> *((a1=map10)[ xp::ref(result) += ',', xp::ref(result) += a1 ]));
+ >> *((a1=map10)[ xp::ref(result) += ',', xp::ref(result) += a1 ]));
std::list<int> result12;
std::map<std::string,int> map12;
TYPEOF_TEST((a1=map12)[ xp::ref(result12)->*push_back( a1 ) ]
Modified: branches/fix-links/tools/bcp/scan_cvs_path.cpp
==============================================================================
--- branches/fix-links/tools/bcp/scan_cvs_path.cpp (original)
+++ branches/fix-links/tools/bcp/scan_cvs_path.cpp 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -136,9 +136,9 @@
{
scan_svn_path(fpath); // recursion for directory entries
}
- // else
- // std::cerr << "WARNING: unknown entry kind for entry " << name
- // << "in " << entries << std::endl;
+ // else
+ // std::cerr << "WARNING: unknown entry kind for entry " << name
+ // << "in " << entries << std::endl;
}
}
++i;
Modified: branches/fix-links/tools/boostbook/xsl/navbar.xsl
==============================================================================
--- branches/fix-links/tools/boostbook/xsl/navbar.xsl (original)
+++ branches/fix-links/tools/boostbook/xsl/navbar.xsl 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -37,7 +37,7 @@
<!-- location of the various Boost elements -->
<xsl:param name = "boost.root" select = "'../..'"/>
- <xsl:param name = "boost.website" select = "'http://beta.boost.org'"/>
+ <xsl:param name = "boost.website" select = "'http://www.boost.org'"/>
<xsl:param name = "boost.image.src"
select = "concat($boost.root, '/boost.png')"/>
<xsl:param name = "boost.image.alt" select = "'Boost C++ Libraries'"/>
@@ -117,12 +117,12 @@
</xsl:variable>
<xsl:variable name="people_link">
<xsl:call-template name="href.target.relative">
- <xsl:with-param name="target" select="concat( $boost.website, '/users/people.html' )"/>
+ <xsl:with-param name="target" select="concat( $boost.website, '/people/people.htm' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="faq_link">
<xsl:call-template name="href.target.relative">
- <xsl:with-param name="target" select="concat( $boost.website, '/users/faq.html' )"/>
+ <xsl:with-param name="target" select="concat( $boost.website, '/more/faq.htm' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="more_link">
Modified: branches/fix-links/tools/build/v2/tools/darwin.jam
==============================================================================
--- branches/fix-links/tools/build/v2/tools/darwin.jam (original)
+++ branches/fix-links/tools/build/v2/tools/darwin.jam 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -171,9 +171,17 @@
# set up the -F option to include the paths to any frameworks used.
local rule prepare-framework-path ( target + )
{
+ # The -framework option only takes basename of the framework.
+ # The -F option specifies the directories where a framework
+ # is searched for. So, if we find <framework> feature
+ # with some path, we need to generate property -F option.
local framework-path = [ on $(target) return $(FRAMEWORK:D) ] ;
-
- FRAMEWORK_PATH on $(target) += -F$(framework-path) ;
+
+ # Be sure to generate no -F if there's no path.
+ if $(framework-path) != ""
+ {
+ FRAMEWORK_PATH on $(target) += -F$(framework-path) ;
+ }
}
rule link
Modified: branches/fix-links/tools/build/v2/tools/msvc.jam
==============================================================================
--- branches/fix-links/tools/build/v2/tools/msvc.jam (original)
+++ branches/fix-links/tools/build/v2/tools/msvc.jam 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -866,7 +866,7 @@
if [ os.name ] in NT
{
- actions link bind DEF_FILE
+ actions link bind DEF_FILE LIBRARIES_MENTIONED_BY_FILE
{
$(.LD) $(LINKFLAGS) /out:"$(<[1]:W)" /LIBPATH:"$(LINKPATH:W)" $(OPTIONS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
if %ERRORLEVEL% NEQ 0 EXIT %ERRORLEVEL%
@@ -875,7 +875,7 @@
)
}
- actions link.dll bind DEF_FILE
+ actions link.dll bind DEF_FILE LIBRARIES_MENTIONED_BY_FILE
{
$(.LD) /DLL $(LINKFLAGS) /out:"$(<[1]:W)" /IMPLIB:"$(<[2]:W)" /LIBPATH:"$(LINKPATH:W)" /def:"$(DEF_FILE)" $(OPTIONS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
if %ERRORLEVEL% NEQ 0 EXIT %ERRORLEVEL%
@@ -886,7 +886,7 @@
}
else
{
- actions link bind DEF_FILE
+ actions link bind DEF_FILE LIBRARIES_MENTIONED_BY_FILE
{
$(.LD) $(LINKFLAGS) /out:"$(<[1]:W)" /LIBPATH:"$(LINKPATH:W)" $(OPTIONS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
if test -e "$(<[1]).manifest"; then
@@ -894,7 +894,7 @@
fi
}
- actions link.dll bind DEF_FILE
+ actions link.dll bind DEF_FILE LIBRARIES_MENTIONED_BY_FILE
{
$(.LD) /DLL $(LINKFLAGS) /out:"$(<[1]:W)" /IMPLIB:"$(<[2]:W)" /LIBPATH:"$(LINKPATH:W)" /def:"$(DEF_FILE)" $(OPTIONS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
if test -e "$(<[1]).manifest"; then
Modified: branches/fix-links/tools/regression/src/regression.py
==============================================================================
--- branches/fix-links/tools/regression/src/regression.py (original)
+++ branches/fix-links/tools/regression/src/regression.py 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
@@ -435,7 +435,7 @@
b = os.path.basename( self.local )
tag = b[ 0: b.find( '.' ) ]
self.log( 'Tag: "%s"' % tag )
- self.unpack_tarball( local, self.boost_root )
+ self.unpack_tarball( self.local, self.boost_root )
elif self.have_source:
if not self.incremental: self.command_cleanup( [ 'bin' ] )
Deleted: branches/fix-links/tools/release/make_tarballs.py
==============================================================================
--- branches/fix-links/tools/release/make_tarballs.py 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,373 +0,0 @@
-# Copyright (c) MetaCommunications, Inc. 2003-2004
-#
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-import sys
-import os
-import shutil
-import optparse
-
-
-import utils
-
-my_location = os.path.abspath( os.path.dirname( sys.argv[0] ) )
-
-def accept_args( args ):
- #( release_version, cvs_tag, sf_user, temp_dir, start_step ) = accept_args( sys.argv[ 1: ] )
- parser = optparse.OptionParser()
- parser.add_option( "-v", "--release-version", dest="release_version", metavar="release-version", help="release version (e.g. 1.32.0)")
- parser.add_option( "", "--tag", dest="tag", help="CVS tag" )
- parser.add_option( "-r", "--cvs-branch", dest="cvs_branch", metavar="cvs-branch"
- , help = "cvs branch to get the sources from (e.g RC_1_32_0). Important: it is case sensitive" )
- parser.add_option( "-u", "--sf-user", dest="sf_user", metavar="sf-user"
- , help = "SourceForge user name (for CVS)" )
- parser.add_option( "-t", "--toolset", dest="toolset", help="toolset to use to build needed tools" )
- parser.add_option( "-s", "--start-step", dest="start_step" )
- parser.usage = "make_tarballs [options] target_directory \n\n" + \
- "Requirements:\n" + \
- " CVS:\n"+ \
- " cvs - (windows) to export sources with windows newlines \n" + \
- " /usr/bin/cvs - (cygwin) to export sources with posix newlines\n" + \
- " Utilities:\n" + \
- " mv - (cygwin) posix move\n" + \
- " /usr/bin/find - (cygwin) to export sources with posix newlines\n" + \
- " 7z - to create zipball\n" + \
- " BoostBook generation:\n" + \
- " bjam\n" + \
- " user-config.jam - in user directory ($HOME/%HOME%) for BoostBook generation\n" + \
- " java\n" + \
- " doxygen\n"
-
-
-
- ( options, args ) = parser.parse_args( args )
-
- temp_dir = None
- start_step = None
- if ( len( args ) > 0 ): temp_dir = args[0]
-
-
- ( version, tag, user, toolset, start_step ) = ( options.release_version
- , options.cvs_branch
- , options.sf_user
- , options.toolset
- , options.start_step )
-
- if ( start_step is None ): start_step = ""
-
- def required( value, name ):
- if ( value is None ):
- print "%s should be specified." % name
- parser.print_help()
- sys.exit( 1 )
-
- required( version, "version" )
- required( tag, "tag" )
- required( user, "user" )
- required( temp_dir, "temp_dir" )
- required( toolset, "toolset" )
-
- return ( version, tag, user, toolset, temp_dir, start_step )
-
-
-def remove_directory( directory ):
- if os.path.exists( directory ):
- print " Removing directory %s" % directory
- os.system( 'rd /s /q "%s"' % directory )
-
-def clean_directory( directory ):
- remove_directory( directory )
- print " Creating directory %s" % directory
- os.makedirs( directory )
-
-def listdir_recursively( root, path="" ):
- # recursive listdir
- files = []
- try:
- for file in os.listdir(os.path.join(root, path)):
- pathname = os.path.join(path, file)
- if os.path.isdir(os.path.join(root, pathname)):
- files.extend(listdir_recursively(root, pathname))
- else:
- files.append(pathname)
- except OSError:
- pass
- return files
-
-def find_file( root, name ):
- print root
- files = listdir_recursively( root )
- for file in files:
- # print file
- if os.path.basename( file ) == name:
- return os.path.join( root, file )
- return None
-
-start_dir = os.getcwd()
-
-class make_tarballs( utils.step_controller ):
- def __init__( self, release_version, cvs_tag, sf_user, toolset, temp_dir, start_step ):
- utils.step_controller.__init__( self, start_step )
- self.release_version_ = release_version
- self.cvs_tag_ = cvs_tag
- self.sf_user_ = sf_user
- self.toolset_ = toolset
- self.temp_dir_ = temp_dir
-
- def run( self ):
- archives = []
-
- win_build_results = self.build_win( self.release_version_
- , self.cvs_tag_
- , self.sf_user_
- , self.temp_dir_ )
- archives.extend( win_build_results[1] )
-
- archives.extend( self.build_unix( self.release_version_
- , self.cvs_tag_
- , self.sf_user_
- , self.temp_dir_
- , win_build_results[0] ) )
-
-
- # os.chdir( start_dir )
- # for archive in archives:
- # shutil.copy( archive, start_dir )
-
-
- def make_temp_platform( self, temp, platform ):
- temp_platform = os.path.join( temp, platform )
- if not self.is_skipping():
- clean_directory( temp_platform )
- return temp_platform
-
- def cvs_export( self, sf_user, cvs_tag, release_version, shell = "%s" ):
- if not self.is_skipping():
- print " Exporting..."
- cvs_export_template = 'cvs -d:ext:%(user)s_at_[hidden]:/cvsroot/boost -z9 export -r %(branch)s boost'
-
- cmd = cvs_export_template % { "user": sf_user
- , "branch" : cvs_tag }
-
- print cmd
- os.system( shell % cmd )
- os.system( "del /S/F/Q .cvsignore >nul" )
- # have to use mv instead of os.rename - cygwin cvs sets strange directory permssions
- # which Windows rename or Python's os.rename cannot deal with
- os.system( "mv boost boost_%s" % release_version )
- return "boost_%s" % release_version
-
- def build_win( self, release_version, cvs_tag, sf_user, temp_dir ):
-
- if "win.export":
- self.start_step( "win.export", "Exporting windows copy" )
-
- temp_win = self.make_temp_platform( temp_dir, "win" )
- os.chdir( temp_win )
-
- exported_dir = self.cvs_export( sf_user, cvs_tag, release_version )
- self.finish_step( "win.export" )
-
- self.make_docs( os.path.abspath( exported_dir ), temp_dir )
-
- if self.start_step( "win.make_readonly", "Making all files writable" ):
- os.chdir( temp_win )
- utils.checked_system( [ "attrib /S -R *.*" ] )
- self.finish_step( "win.make_readonly" )
-
- zip_name = "boost_%s.zip" % release_version
- os.chdir( temp_win )
-
-
- if self.start_step( "win.zip", " Zipping" ):
- print " Zipping"
- if os.path.exists( zip_name ): os.unlink( zip_name )
-
- utils.checked_system( ["7z a -r -tzip %s %s\* > %s" % ( zip_name, "boost_%s" % release_version, zip_name + ".log" ) ] )
- self.finish_step( "win.zip" )
-
-
- return ( os.path.abspath( exported_dir ), [ os.path.abspath( zip_name ) ] )
-
- def make_docs( self, boost_directory, temp_dir ):
- boostbook_temp = os.path.join( boost_directory, "bin.v2" )
- tools_directory = os.path.join( temp_dir, "tools" )
- if not os.path.exists( tools_directory ):
- os.makedirs( tools_directory )
-
- if self.start_step( "win.make_docs.setup_tools", "Setting up BoostBook tools" ):
- sys.path.append( sys.path[0] + "/../boostbook" )
- print sys.path
- import setup_boostbook
- os.environ[ "BOOST_ROOT" ] = boost_directory
- setup_boostbook.setup_boostbook( os.path.join( temp_dir, "tools" ) )
-
- if self.start_step( "win.make_docs.clean", "Clearing \"bin.v2" ):
- if os.path.exists( boostbook_temp ):
- shutil.rmtree( boostbook_temp )
- self.finish_step( "win.make_docs.clean" )
-
-
- cd = os.getcwd()
- os.chdir( os.path.join( boost_directory, "doc" ) )
-
- if self.start_step( "win.make_docs.correct_permissions", "Making html's writable" ):
- utils.checked_system(
- [
- "cd html"
- , "attrib -R *"
- , "cd .."
- ] )
- self.finish_step( "win.make_docs.correct_permissions" )
-
- def generate( output_format ):
- if self.start_step( "win.make_docs.%s" % output_format, ' Generating %s' % output_format ):
- utils.checked_system( [
- # "set HOME=%s" % my_location
- "%s -d2 --v2 %s " % ( bjam_path(), output_format )
- ] )
- self.finish_step( "win.make_docs.%s" % output_format )
-
- generate( "html" )
- generate( "docbook" )
- generate( "fo" )
-
- if self.start_step( "win.make_docs.copy_docs", "Copying docs into doc directory" ):
- shutil.copy( os.path.join( boostbook_temp, "doc", self.toolset_, "debug", "boost.docbook" ), "boost.docbook" )
- shutil.copy( os.path.join( boostbook_temp, "doc", self.toolset_, "debug", "boost.fo" ), "boost.fo" )
- self.finish_step( "win.make_docs.copy_docs" )
-
-
- if self.start_step( "win.make_docs.clean2", "Copying docs into doc directory" ):
- shutil.rmtree( boostbook_temp )
- shutil.rmtree( "xml" )
- self.finish_step( "win.make_docs.clean2" )
-
- if self.start_step( "win.make_docs.bb_userman", "Creating Boost.Build user manual" ):
- os.chdir( os.path.join( boost_directory, "tools", "build", "v2", "doc" ) )
-
- utils.checked_system( [
-# "set HOME=%s" % my_location
- "%s -d2 --v2 pdf" % bjam_path()
- ] )
-
- for f in [ "userman.pdf" ]:
- shutil.copy( find_file( os.path.join( boostbook_temp ), f ), f )
-
- shutil.rmtree( boostbook_temp )
- self.finish_step( "win.make_docs.bb_userman" )
-
- if self.start_step( "win.make_docs.clean3", boost_directory ):
- for i in os.walk( boost_directory ):
- for f in i[2]:
- full_path = os.path.join( i[0], f )
- if os.path.splitext( f )[1] in [ ".boostbook" ] \
- and os.access( full_path, os.W_OK ):
- os.unlink( full_path )
- self.finish_step( "win.make_docs.clean3" )
-
-
- def correct_executable_permissions( self, path ):
- if not self.is_skipping():
- print " Correcting permissions"
- for i in os.walk( path ):
- for f in i[2]:
- if os.path.splitext( f )[1] in ( ".css", ".hpp", ".cpp",\
- ".html", ".htm", ".rst", \
- ".pdf", ".xml", ".png",\
- ".jpg", ".vcproj", ".pattern2", \
- ".jam", ".bat", ".sty", ".diff" ) \
- or os.path.basename( f ).lower() in ( "jamfile", "todo", "makefile", "jamrules", "gnumakefile" ):
- print os.path.join( i[0], f )
- os.system( "chmod a-x %s" % os.path.join( i[0], f ) )
-
-
- def build_unix( self, release_version, cvs_tag, sf_user, temp_dir, win_build_dir ):
-
- self.start_step( "unix.export", "Exporting unix copy" )
-
- temp_unix = self.make_temp_platform( temp_dir, "unix" )
- os.chdir( temp_unix )
-
- exported_dir = self.cvs_export( sf_user, cvs_tag, release_version, "bash -c \"/usr/bin/%s\"" )
- self.correct_executable_permissions( "." )
- self.finish_step( "unix.export" )
-
- self.copy_docs_to_unix( os.path.abspath( exported_dir )
- , win_build_dir )
-
- if self.start_step( "unix.make_readonly", "Making all files readonly" ):
- utils.checked_system( [ "chmod -R a-w+r,u+w %s" % temp_unix ] )
- utils.checked_system( [ "bash -c /usr/bin/find %s -type d -exec chmod u+w {} ;" % temp_unix ] )
- self.finish_step( "unix.make_readonly" )
-
- gz_archive_name = "boost_%s" % release_version + ".tar.gz"
- if self.start_step( "unix.gz", " Making .gz" ):
- if os.path.exists( gz_archive_name ): os.unlink( gz_archive_name )
- os.system( "tar cfz %s %s" % ( gz_archive_name, "boost_%s" % release_version ) )
- self.finish_step( "unix.gz" )
-
- bz2_archive_name = "boost_%s" % release_version + ".tar.bz2"
- if self.start_step( "unix.bz2", " Making .bz2" ):
- if os.path.exists( bz2_archive_name ): os.unlink( bz2_archive_name )
- os.system( 'bash -c "gunzip -c %s | bzip2 > %s"' % ( gz_archive_name, bz2_archive_name ) )
- self.finish_step( "unix.bz2" )
-
- return [ os.path.abspath( x ) for x in ( gz_archive_name, bz2_archive_name ) ]
-
- def remove_x_permission( self, directory ):
- for i in os.walk( directory ):
- for f in i[1]:
- os.system( "chmod a=xr,u=rwx %s" % os.path.join( i[0], f ) )
- for f in i[2]:
- os.system( "chmod a=r,u=rw %s" % os.path.join( i[0], f ) )
-
- def copy_docs_to_unix( self, unix_boost_directory, win_boost_directory ):
- if self.start_step( "unix.copy_docs", "Copying docs to unix copy" ):
- doc_directory = os.path.join( unix_boost_directory, "doc" )
- doc_html_directory = os.path.join( doc_directory, "html" )
- remove_directory( doc_html_directory )
- utils.checked_system( [
- "cp -R %s %s " % ( os.path.join( win_boost_directory, "doc", "html" )
- , doc_html_directory )
- ] )
- for f in [ "boost.docbook", "boost.fo" ]:
- utils.checked_system( [
- "cp %s %s" % ( os.path.join( win_boost_directory, "doc", f )
- , os.path.join( doc_directory, f ) )
- ] )
-
- self.remove_x_permission( doc_directory )
-
- boost_build_doc_directory = os.path.join( unix_boost_directory, "tools", "build", "v2", "doc" )
- boost_build_doc_html_directory = os.path.join( boost_build_doc_directory, "html" )
-
- remove_directory( boost_build_doc_html_directory )
- utils.checked_system( [
- "cp -R %s %s " % ( os.path.join( win_boost_directory, "tools", "build", "v2", "doc", "html" )
- , boost_build_doc_html_directory ) ] )
-
- for f in [ "userman.pdf" ]:
- utils.checked_system( [
- "cp %s %s " % ( os.path.join( win_boost_directory, "tools", "build", "v2", "doc", f )
- , os.path.join( boost_build_doc_directory, f ) ) ] )
-
- self.remove_x_permission( boost_build_doc_directory )
- self.finish_step( "unix.copy_docs" )
-
-
-def bjam_path():
- if os.path.exists( os.path.join( my_location, "bjam.exe" ) ):
- return os.path.join( my_location, "bjam.exe" )
- else:
- return "bjam.exe"
-
-def main():
- ( release_version, cvs_tag, sf_user, toolset, temp_dir, start_step ) = accept_args( sys.argv[ 1: ] )
-
- make_tarballs( release_version, cvs_tag, sf_user, toolset, temp_dir, start_step ).run()
-
-if __name__ == "__main__":
- main()
Deleted: branches/fix-links/tools/release/utils.py
==============================================================================
--- branches/fix-links/tools/release/utils.py 2008-02-07 13:54:14 EST (Thu, 07 Feb 2008)
+++ (empty file)
@@ -1,52 +0,0 @@
-import string
-
-import os
-
-class failure_exception:
- def __init__( self, rc ):
- self.rc_ = rc
-
- def __str__( self ):
- return "rc: %d" % self.rc_
-
-def system( commands ):
- if os.path.exists( "tmp.cmd" ):
- os.chmod( "tmp.cmd", 0777 )
- os.unlink( "tmp.cmd" )
-
- f = open( "tmp.cmd", "w" )
- f.write( string.join( commands, "\n" ) )
- f.close()
- rc = os.system( "tmp.cmd" )
- os.chmod( "tmp.cmd", 0777 )
- os.unlink( "tmp.cmd" )
- return rc
-
-def checked_system( commands, valid_return_codes = [ 0 ] ):
- rc = system( commands )
- if rc not in [ 0 ] + valid_return_codes: raise failure_exception( rc )
- return rc
-
-class step_controller:
- def __init__( self, start_step ):
- self.current_step_ = None;
- self.skip_to_step_ = start_step
-
- def start_step( self, step_name, start_message ):
- self.current_step_ = step_name
- if self.is_skipping( step_name ):
- print "[%s] Skipping." % step_name
- return 0
- else:
- self.skip_to_step_ = ""
- print "[%s] %s" % ( step_name, start_message )
- return 1
-
- def finish_step( self, step_name ):
- print "[%s] Finished" % step_name
-
- def is_skipping( self, step_name = None ):
- if step_name is None: step_name = self.current_step_
- return self.skip_to_step_ != "" and self.skip_to_step_ != step_name
-
-
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk