Subject: [Boost-commit] svn:boost r53142 - in branches/release: boost/algorithm/string/detail boost/archive/impl boost/bimap boost/bimap/detail boost/circular_buffer boost/date_time boost/exception/detail boost/format boost/function boost/graph boost/graph/detail boost/graph/planar_detail boost/interprocess boost/interprocess/containers/container boost/interprocess/detail boost/intrusive boost/iostreams boost/iostreams/filter boost/math/special_functions boost/math/special_functions/detail boost/numeric/ublas boost/numeric/ublas/detail boost/pending boost/pool boost/program_options boost/python boost/random boost/test/impl boost/test/utils/runtime/file boost/type_traits boost/utility libs/accumulators/example libs/interprocess/test libs/iostreams/src libs/iostreams/test libs/numeric/ublas/test libs/optional/test libs/python/test libs/rational/test libs/serialization/example libs/serialization/src libs/spirit/classic/example/intermediate/simple_xml libs/utility/swap/test tools/regression/src
From: jewillco_at_[hidden]
Date: 2009-05-20 15:41:31
Author: jewillco
Date: 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
New Revision: 53142
URL: http://svn.boost.org/trac/boost/changeset/53142
Log:
Fixed almost all tab and min/max issues found by inspect tool
Text files modified:
branches/release/boost/algorithm/string/detail/classification.hpp | 2
branches/release/boost/archive/impl/text_iarchive_impl.ipp | 2
branches/release/boost/bimap/detail/bimap_core.hpp | 46 +-
branches/release/boost/bimap/detail/set_view_base.hpp | 2
branches/release/boost/bimap/list_of.hpp | 4
branches/release/boost/bimap/multiset_of.hpp | 6
branches/release/boost/bimap/set_of.hpp | 8
branches/release/boost/bimap/unconstrained_set_of.hpp | 4
branches/release/boost/bimap/unordered_multiset_of.hpp | 8
branches/release/boost/bimap/unordered_set_of.hpp | 8
branches/release/boost/bimap/vector_of.hpp | 4
branches/release/boost/circular_buffer/base.hpp | 2
branches/release/boost/date_time/date_parsing.hpp | 4
branches/release/boost/exception/detail/exception_ptr_base.hpp | 22
branches/release/boost/format/parsing.hpp | 2
branches/release/boost/function/function_template.hpp | 2
branches/release/boost/graph/detail/adjacency_list.hpp | 2
branches/release/boost/graph/howard_cycle_ratio.hpp | 2
branches/release/boost/graph/is_straight_line_drawing.hpp | 2
branches/release/boost/graph/isomorphism.hpp | 4
branches/release/boost/graph/make_connected.hpp | 2
branches/release/boost/graph/make_maximal_planar.hpp | 10
branches/release/boost/graph/planar_canonical_ordering.hpp | 6
branches/release/boost/graph/planar_detail/boyer_myrvold_impl.hpp | 4
branches/release/boost/graph/planar_face_traversal.hpp | 2
branches/release/boost/interprocess/containers/container/stable_vector.hpp | 10
branches/release/boost/interprocess/detail/move.hpp | 2
branches/release/boost/interprocess/detail/workaround.hpp | 2
branches/release/boost/interprocess/mapped_region.hpp | 5
branches/release/boost/intrusive/priority_compare.hpp | 2
branches/release/boost/iostreams/close.hpp | 16
branches/release/boost/iostreams/filter/newline.hpp | 2
branches/release/boost/math/special_functions/detail/fp_traits.hpp | 2
branches/release/boost/math/special_functions/fpclassify.hpp | 8
branches/release/boost/numeric/ublas/detail/concepts.hpp | 2
branches/release/boost/numeric/ublas/functional.hpp | 266 +++++++-------
branches/release/boost/numeric/ublas/triangular.hpp | 34
branches/release/boost/pending/fibonacci_heap.hpp | 2
branches/release/boost/pool/pool_alloc.hpp | 16
branches/release/boost/program_options/positional_options.hpp | 2
branches/release/boost/python/enum.hpp | 2
branches/release/boost/python/make_constructor.hpp | 6
branches/release/boost/random/uniform_int.hpp | 2
branches/release/boost/test/impl/unit_test_parameters.ipp | 445 +++++++++++++++----------
branches/release/boost/test/utils/runtime/file/config_file_iterator.cpp | 7
branches/release/boost/type_traits/alignment_of.hpp | 10
branches/release/boost/utility/result_of.hpp | 4
branches/release/libs/accumulators/example/main.cpp | 2
branches/release/libs/interprocess/test/message_queue_test.cpp | 6
branches/release/libs/iostreams/src/file_descriptor.cpp | 2
branches/release/libs/iostreams/src/mapped_file.cpp | 695 ++++++++++++++++++++-------------------
branches/release/libs/iostreams/test/large_file_test.cpp | 4
branches/release/libs/iostreams/test/mapped_file_test.cpp | 172 +++++++--
branches/release/libs/numeric/ublas/test/triangular_layout.cpp | 234 ++++++------
branches/release/libs/optional/test/optional_test_ref.cpp | 8
branches/release/libs/python/test/map_indexing_suite.cpp | 2
branches/release/libs/rational/test/rational_test.cpp | 9
branches/release/libs/serialization/example/portable_binary_iarchive.hpp | 4
branches/release/libs/serialization/src/extended_type_info_typeid.cpp | 4
branches/release/libs/spirit/classic/example/intermediate/simple_xml/tag.hpp | 4
branches/release/libs/utility/swap/test/std_bitset.cpp | 2
branches/release/libs/utility/swap/test/swap_test_class.hpp | 2
branches/release/tools/regression/src/library_status.cpp | 18
63 files changed, 1187 insertions(+), 988 deletions(-)
Modified: branches/release/boost/algorithm/string/detail/classification.hpp
==============================================================================
--- branches/release/boost/algorithm/string/detail/classification.hpp (original)
+++ branches/release/boost/algorithm/string/detail/classification.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -171,7 +171,7 @@
// Check what kind of storage are we using right now
if(use_fixed_storage(m_Size))
{
- // Using fixed storage, allocate new
+ // Using fixed storage, allocate new
set_value_type* pTemp=new set_value_type[Other.m_Size];
DestStorage=pTemp;
m_Storage.m_dynSet=pTemp;
Modified: branches/release/boost/archive/impl/text_iarchive_impl.ipp
==============================================================================
--- branches/release/boost/archive/impl/text_iarchive_impl.ipp (original)
+++ branches/release/boost/archive/impl/text_iarchive_impl.ipp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -54,7 +54,7 @@
#endif
s.resize(size);
if(0 < size)
- is.read(&(*s.begin()), size);
+ is.read(&(*s.begin()), size);
}
#ifndef BOOST_NO_CWCHAR
Modified: branches/release/boost/bimap/detail/bimap_core.hpp
==============================================================================
--- branches/release/boost/bimap/detail/bimap_core.hpp (original)
+++ branches/release/boost/bimap/detail/bimap_core.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -93,33 +93,33 @@
<
RightSetType
- >::type right_set_type;
+ >::type right_set_type;
-
- private:
+
+ private:
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::default_tagged
- <
- BOOST_DEDUCED_TYPENAME left_set_type::user_type,
- ::boost::bimaps::relation::member_at::left
-
- >::type left_tagged_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::default_tagged
+ <
+ BOOST_DEDUCED_TYPENAME left_set_type::user_type,
+ ::boost::bimaps::relation::member_at::left
+
+ >::type left_tagged_type;
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::default_tagged
- <
- BOOST_DEDUCED_TYPENAME right_set_type::user_type,
- ::boost::bimaps::relation::member_at::right
-
- >::type right_tagged_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::default_tagged
+ <
+ BOOST_DEDUCED_TYPENAME right_set_type::user_type,
+ ::boost::bimaps::relation::member_at::right
+
+ >::type right_tagged_type;
- public:
+ public:
- //@{
+ //@{
- typedef BOOST_DEDUCED_TYPENAME left_tagged_type::tag left_tag;
- typedef BOOST_DEDUCED_TYPENAME right_tagged_type::tag right_tag;
+ typedef BOOST_DEDUCED_TYPENAME left_tagged_type::tag left_tag;
+ typedef BOOST_DEDUCED_TYPENAME right_tagged_type::tag right_tag;
- //@}
+ //@}
//@{
@@ -279,7 +279,7 @@
/* else */ BOOST_DEDUCED_TYPENAME mpl::if_<
is_same< BOOST_DEDUCED_TYPENAME parameters::set_type_of_relation, right_based >,
// {
- ::boost::bimaps::tags::tagged< right_set_type, right_tag >,
+ ::boost::bimaps::tags::tagged< right_set_type, right_tag >,
// }
// else
// {
@@ -496,7 +496,7 @@
template< class BimapBaseType >
struct left_map_view_type
{
- typedef BOOST_DEDUCED_TYPENAME BimapBaseType::left_set_type left_set_type;
+ typedef BOOST_DEDUCED_TYPENAME BimapBaseType::left_set_type left_set_type;
typedef BOOST_DEDUCED_TYPENAME
left_set_type::BOOST_NESTED_TEMPLATE map_view_bind<
BOOST_DEDUCED_TYPENAME BimapBaseType::left_tag, BimapBaseType
@@ -506,7 +506,7 @@
template< class BimapBaseType >
struct right_map_view_type
{
- typedef BOOST_DEDUCED_TYPENAME BimapBaseType::right_set_type right_set_type;
+ typedef BOOST_DEDUCED_TYPENAME BimapBaseType::right_set_type right_set_type;
typedef BOOST_DEDUCED_TYPENAME
right_set_type::BOOST_NESTED_TEMPLATE map_view_bind<
BOOST_DEDUCED_TYPENAME BimapBaseType::right_tag, BimapBaseType
Modified: branches/release/boost/bimap/detail/set_view_base.hpp
==============================================================================
--- branches/release/boost/bimap/detail/set_view_base.hpp (original)
+++ branches/release/boost/bimap/detail/set_view_base.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -45,7 +45,7 @@
template< class MutantRelationStorage, class KeyToBase >
class set_view_key_to_base<MutantRelationStorage,MutantRelationStorage,KeyToBase>
{
- typedef BOOST_DEDUCED_TYPENAME MutantRelationStorage::non_mutable_storage non_mutable_storage;
+ typedef BOOST_DEDUCED_TYPENAME MutantRelationStorage::non_mutable_storage non_mutable_storage;
public:
const MutantRelationStorage & operator()( const non_mutable_storage & k ) const
{
Modified: branches/release/boost/bimap/list_of.hpp
==============================================================================
--- branches/release/boost/bimap/list_of.hpp (original)
+++ branches/release/boost/bimap/list_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -107,8 +107,8 @@
typedef Type user_type;
/// Type of the object that will be stored in the list
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
struct lazy_concept_checked
Modified: branches/release/boost/bimap/multiset_of.hpp
==============================================================================
--- branches/release/boost/bimap/multiset_of.hpp (original)
+++ branches/release/boost/bimap/multiset_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -109,7 +109,7 @@
<
class KeyType,
class KeyCompare = std::less< BOOST_DEDUCED_TYPENAME
- ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
>
struct multiset_of : public ::boost::bimaps::detail::set_type_of_tag
{
@@ -117,8 +117,8 @@
typedef KeyType user_type;
/// Type of the object that will be stored in the multiset
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
/// Functor that compare two keys
typedef KeyCompare key_compare;
Modified: branches/release/boost/bimap/set_of.hpp
==============================================================================
--- branches/release/boost/bimap/set_of.hpp (original)
+++ branches/release/boost/bimap/set_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -110,16 +110,16 @@
<
class KeyType,
class KeyCompare = std::less< BOOST_DEDUCED_TYPENAME
- ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
>
struct set_of : public ::boost::bimaps::detail::set_type_of_tag
{
- /// User type, can be tagged
+ /// User type, can be tagged
typedef KeyType user_type;
/// Type of the object that will be stored in the set
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
/// Functor that compare two keys
typedef KeyCompare key_compare;
Modified: branches/release/boost/bimap/unconstrained_set_of.hpp
==============================================================================
--- branches/release/boost/bimap/unconstrained_set_of.hpp (original)
+++ branches/release/boost/bimap/unconstrained_set_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -67,8 +67,8 @@
typedef KeyType user_type;
/// Type of the object that will be stored in the container
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
struct lazy_concept_checked
{
Modified: branches/release/boost/bimap/unordered_multiset_of.hpp
==============================================================================
--- branches/release/boost/bimap/unordered_multiset_of.hpp (original)
+++ branches/release/boost/bimap/unordered_multiset_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -118,9 +118,9 @@
<
class KeyType,
class HashFunctor = hash< BOOST_DEDUCED_TYPENAME
- ::boost::bimaps::tags::support::value_type_of<KeyType>::type >,
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >,
class EqualKey = std::equal_to< BOOST_DEDUCED_TYPENAME
- ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
>
struct unordered_multiset_of : public ::boost::bimaps::detail::set_type_of_tag
{
@@ -128,8 +128,8 @@
typedef KeyType user_type;
/// Type of the object that will be stored in the container
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
/// Hash Functor that takes value_type objects
typedef HashFunctor hasher;
Modified: branches/release/boost/bimap/unordered_set_of.hpp
==============================================================================
--- branches/release/boost/bimap/unordered_set_of.hpp (original)
+++ branches/release/boost/bimap/unordered_set_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -115,9 +115,9 @@
<
class KeyType,
class HashFunctor = hash< BOOST_DEDUCED_TYPENAME
- ::boost::bimaps::tags::support::value_type_of<KeyType>::type >,
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >,
class EqualKey = std::equal_to< BOOST_DEDUCED_TYPENAME
- ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
>
struct unordered_set_of : public ::boost::bimaps::detail::set_type_of_tag
{
@@ -125,8 +125,8 @@
typedef KeyType user_type;
/// Type of the object that will be stored in the container
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
/// Hash Functor that takes value_type objects
typedef HashFunctor hasher;
Modified: branches/release/boost/bimap/vector_of.hpp
==============================================================================
--- branches/release/boost/bimap/vector_of.hpp (original)
+++ branches/release/boost/bimap/vector_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -112,8 +112,8 @@
typedef Type user_type;
/// Type of the object that will be stored in the vector
- typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
- value_type_of<user_type>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
struct lazy_concept_checked
Modified: branches/release/boost/circular_buffer/base.hpp
==============================================================================
--- branches/release/boost/circular_buffer/base.hpp (original)
+++ branches/release/boost/circular_buffer/base.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -709,7 +709,7 @@
iterators pointing to the first <code>n</code> elements; does not invalidate any iterators if the
<code>circular_buffer</code> is full.
\par Complexity
- Linear (in <code>std::min(m, n)</code>); constant if the <code>circular_buffer</code> is full.
+ Linear (in <code>(std::min)(m, n)</code>); constant if the <code>circular_buffer</code> is full.
\sa <code>std::rotate</code>
*/
void rotate(const_iterator new_begin) {
Modified: branches/release/boost/date_time/date_parsing.hpp
==============================================================================
--- branches/release/boost/date_time/date_parsing.hpp (original)
+++ branches/release/boost/date_time/date_parsing.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -78,8 +78,8 @@
* must contain 'size' elements. The index of the match is returned.
* If no match is found, 'size' is returned.
* Ex. "Jan" returns 0, "Dec" returns 11, "Tue" returns 2.
- * 'size' can be sent in with: greg_month::max() (which 12),
- * greg_weekday::max() + 1 (which is 7) or date_time::NumSpecialValues */
+ * 'size' can be sent in with: (greg_month::max)() (which 12),
+ * (greg_weekday::max)() + 1 (which is 7) or date_time::NumSpecialValues */
template<class charT>
short find_match(const charT* const* short_names,
const charT* const* long_names,
Modified: branches/release/boost/exception/detail/exception_ptr_base.hpp
==============================================================================
--- branches/release/boost/exception/detail/exception_ptr_base.hpp (original)
+++ branches/release/boost/exception/detail/exception_ptr_base.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -9,18 +9,18 @@
namespace
boost
{
- namespace
- exception_detail
- {
- class
- exception_ptr_base
- {
- public:
+ namespace
+ exception_detail
+ {
+ class
+ exception_ptr_base
+ {
+ public:
- virtual void _rethrow() const=0;
- virtual bool _empty() const=0;
- };
- }
+ virtual void _rethrow() const=0;
+ virtual bool _empty() const=0;
+ };
+ }
}
#endif
Modified: branches/release/boost/format/parsing.hpp
==============================================================================
--- branches/release/boost/format/parsing.hpp (original)
+++ branches/release/boost/format/parsing.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -48,7 +48,7 @@
#if ! defined( BOOST_NO_LOCALE_ISDIGIT )
return fac.is(std::ctype<Ch>::digit, c);
# else
- (void) fac; // remove "unused parameter" warning
+ (void) fac; // remove "unused parameter" warning
using namespace std;
return isdigit(c);
#endif
Modified: branches/release/boost/function/function_template.hpp
==============================================================================
--- branches/release/boost/function/function_template.hpp (original)
+++ branches/release/boost/function/function_template.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -949,7 +949,7 @@
this->vtable = f.vtable;
f.vtable->manager(f.functor, this->functor,
boost::detail::function::move_functor_tag);
- f.vtable = 0;
+ f.vtable = 0;
#if !defined(BOOST_NO_EXCEPTIONS)
} else {
clear();
Modified: branches/release/boost/graph/detail/adjacency_list.hpp
==============================================================================
--- branches/release/boost/graph/detail/adjacency_list.hpp (original)
+++ branches/release/boost/graph/detail/adjacency_list.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -791,7 +791,7 @@
// of loop edges. This solution is based on the observation that
// the incidence edges of a vertex with a loop are adjacent in the
// out edge list. This *may* actually hold for multisets also.
- bool skip = (next(i) != end && i->get_iter() == next(i)->get_iter());
+ bool skip = (boost::next(i) != end && i->get_iter() == boost::next(i)->get_iter());
g.m_edges.erase((*i).get_iter());
if(skip) ++i;
}
Modified: branches/release/boost/graph/howard_cycle_ratio.hpp
==============================================================================
--- branches/release/boost/graph/howard_cycle_ratio.hpp (original)
+++ branches/release/boost/graph/howard_cycle_ratio.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -52,7 +52,7 @@
* \param ewm2 - edge weight2 read property map: E -> R+
*
* \return maximum_{for all cycles C}CR(C), or
- * -(std::numeric_limits<double>)::max() if g is not "good".
+ * -(std::numeric_limits<double>::max)() if g is not "good".
*/
template <typename TGraph, typename TVertexIndexMap,
typename TWeight1EdgeMap, typename TWeight2EdgeMap >
Modified: branches/release/boost/graph/is_straight_line_drawing.hpp
==============================================================================
--- branches/release/boost/graph/is_straight_line_drawing.hpp (original)
+++ branches/release/boost/graph/is_straight_line_drawing.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -185,7 +185,7 @@
before = active_edges.end();
else
before = prior(a_itr);
- after = next(a_itr);
+ after = boost::next(a_itr);
if (before != active_edges.end())
{
Modified: branches/release/boost/graph/isomorphism.hpp
==============================================================================
--- branches/release/boost/graph/isomorphism.hpp (original)
+++ branches/release/boost/graph/isomorphism.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -237,7 +237,7 @@
num_edges_on_k = 1;
BOOST_USING_STD_MAX();
int next_k = max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num_k, max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num[i], dfs_num[j]));
- if (match(next(iter), next_k))
+ if (match(boost::next(iter), next_k))
return true;
in_S[v] = false;
}
@@ -247,7 +247,7 @@
else {
if (container_contains(adjacent_vertices(f[i], G2), f[j])) {
++num_edges_on_k;
- if (match(next(iter), dfs_num_k))
+ if (match(boost::next(iter), dfs_num_k))
return true;
}
Modified: branches/release/boost/graph/make_connected.hpp
==============================================================================
--- branches/release/boost/graph/make_connected.hpp (original)
+++ branches/release/boost/graph/make_connected.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -62,7 +62,7 @@
if (ci_prev == ci_end)
return;
- for(vec_of_vertices_itr_t ci = next(ci_prev);
+ for(vec_of_vertices_itr_t ci = boost::next(ci_prev);
ci != ci_end; ci_prev = ci, ++ci
)
{
Modified: branches/release/boost/graph/make_maximal_planar.hpp
==============================================================================
--- branches/release/boost/graph/make_maximal_planar.hpp (original)
+++ branches/release/boost/graph/make_maximal_planar.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -130,7 +130,7 @@
// The iterator manipulations on the next two lines are safe because
// vertices_on_face.size() > 3 (from the first test in this function)
fi_end = prior(vertices_on_face.end());
- for(face_iterator fi = next(next(vertices_on_face.begin()));
+ for(face_iterator fi = boost::next(boost::next(vertices_on_face.begin()));
fi != fi_end; ++fi
)
{
@@ -145,7 +145,7 @@
{
add_edge_range(
vertices_on_face[0],
- next(next(vertices_on_face.begin())),
+ boost::next(boost::next(vertices_on_face.begin())),
prior(vertices_on_face.end())
);
}
@@ -153,13 +153,13 @@
{
add_edge_range(
vertices_on_face[1],
- next(marked_neighbor),
+ boost::next(marked_neighbor),
vertices_on_face.end()
);
add_edge_range(
- *next(marked_neighbor),
- next(next(vertices_on_face.begin())),
+ *boost::next(marked_neighbor),
+ boost::next(boost::next(vertices_on_face.begin())),
marked_neighbor
);
}
Modified: branches/release/boost/graph/planar_canonical_ordering.hpp
==============================================================================
--- branches/release/boost/graph/planar_canonical_ordering.hpp (original)
+++ branches/release/boost/graph/planar_canonical_ordering.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -101,7 +101,7 @@
{
edge_t e(*ei); // e = (u,v)
- next_edge_itr = next(ei) == ei_end ? ei_start : next(ei);
+ next_edge_itr = boost::next(ei) == ei_end ? ei_start : boost::next(ei);
vertex_t v = source(e,g) == u ? target(e,g) : source(e,g);
vertex_t prior_vertex = source(*prior_edge_itr, g) == u ?
@@ -127,8 +127,8 @@
// past any loops or parallel edges
while (next_vertex == v || next_vertex == u)
{
- next_edge_itr = next(next_edge_itr) == ei_end ?
- ei_start : next(next_edge_itr);
+ next_edge_itr = boost::next(next_edge_itr) == ei_end ?
+ ei_start : boost::next(next_edge_itr);
next_vertex = source(*next_edge_itr, g) == u ?
target(*next_edge_itr, g) : source(*next_edge_itr, g);
}
Modified: branches/release/boost/graph/planar_detail/boyer_myrvold_impl.hpp
==============================================================================
--- branches/release/boost/graph/planar_detail/boyer_myrvold_impl.hpp (original)
+++ branches/release/boost/graph/planar_detail/boyer_myrvold_impl.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -1025,7 +1025,7 @@
garbage.splice(garbage.end(),
*separated_dfs_child_list[dfs_parent[v]],
to_delete,
- next(to_delete)
+ boost::next(to_delete)
);
}
@@ -1589,7 +1589,7 @@
if (w == graph_traits<Graph>::null_vertex() &&
externally_active(current_vertex,v) &&
outer_face_edge[e] &&
- outer_face_edge[*next(old_face_itr)] &&
+ outer_face_edge[*boost::next(old_face_itr)] &&
!seen_x_or_y
)
{
Modified: branches/release/boost/graph/planar_face_traversal.hpp
==============================================================================
--- branches/release/boost/graph/planar_face_traversal.hpp (original)
+++ branches/release/boost/graph/planar_face_traversal.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -107,7 +107,7 @@
{
edge_t e(*pi);
std::map<vertex_t, edge_t> m = get(next_edge, e);
- m[v] = next(pi) == pi_end ? *pi_begin : *next(pi);
+ m[v] = boost::next(pi) == pi_end ? *pi_begin : *boost::next(pi);
put(next_edge, e, m);
}
}
Modified: branches/release/boost/interprocess/containers/container/stable_vector.hpp
==============================================================================
--- branches/release/boost/interprocess/containers/container/stable_vector.hpp (original)
+++ branches/release/boost/interprocess/containers/container/stable_vector.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -263,12 +263,12 @@
friend class iterator<T, const T, typename boost::pointer_to_other<Pointer, T>::type>;
public:
- typedef std::random_access_iterator_tag iterator_category;
- typedef Value value_type;
- typedef typename std::iterator_traits
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef Value value_type;
+ typedef typename std::iterator_traits
<Pointer>::difference_type difference_type;
- typedef Pointer pointer;
- typedef Value & reference;
+ typedef Pointer pointer;
+ typedef Value & reference;
iterator()
{}
Modified: branches/release/boost/interprocess/detail/move.hpp
==============================================================================
--- branches/release/boost/interprocess/detail/move.hpp (original)
+++ branches/release/boost/interprocess/detail/move.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -744,4 +744,4 @@
} //namespace interprocess {
} //namespace boost {
-#endif //#ifndef BOOST_INTERPROCESS_MOVE_HPP
+#endif //#ifndef BOOST_INTERPROCESS_MOVE_HPP
Modified: branches/release/boost/interprocess/detail/workaround.hpp
==============================================================================
--- branches/release/boost/interprocess/detail/workaround.hpp (original)
+++ branches/release/boost/interprocess/detail/workaround.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -36,7 +36,7 @@
# define BOOST_INTERPROCESS_POSIX_PROCESS_SHARED
# endif
#endif
-
+
#if ((_POSIX_BARRIERS - 0) > 0)
# define BOOST_INTERPROCESS_POSIX_BARRIERS
# endif
Modified: branches/release/boost/interprocess/mapped_region.hpp
==============================================================================
--- branches/release/boost/interprocess/mapped_region.hpp (original)
+++ branches/release/boost/interprocess/mapped_region.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -247,12 +247,9 @@
error_info err(winapi::get_last_error());
throw interprocess_exception(err);
}
- #ifdef max
- #undef max
- #endif
if(static_cast<unsigned __int64>(total_size) >
- std::numeric_limits<std::size_t>::max()){
+ (std::numeric_limits<std::size_t>::max)()){
error_info err(size_error);
throw interprocess_exception(err);
}
Modified: branches/release/boost/intrusive/priority_compare.hpp
==============================================================================
--- branches/release/boost/intrusive/priority_compare.hpp (original)
+++ branches/release/boost/intrusive/priority_compare.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -23,7 +23,7 @@
template <class T>
struct priority_compare
- : public std::binary_function<T, T, bool>
+ : public std::binary_function<T, T, bool>
{
bool operator()(const T &val, const T &val2) const
{
Modified: branches/release/boost/iostreams/close.hpp
==============================================================================
--- branches/release/boost/iostreams/close.hpp (original)
+++ branches/release/boost/iostreams/close.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -99,10 +99,10 @@
#ifdef BOOST_IOSTREAMS_STRICT
assert(which == BOOST_IOS::in || which == BOOST_IOS::out);
#else
- if (which == (BOOST_IOS::in | BOOST_IOS::out)) {
- detail::close_all(t);
- return;
- }
+ if (which == (BOOST_IOS::in | BOOST_IOS::out)) {
+ detail::close_all(t);
+ return;
+ }
#endif
detail::close_impl<T>::close(detail::unwrap(t), which);
}
@@ -113,10 +113,10 @@
#ifdef BOOST_IOSTREAMS_STRICT
assert(which == BOOST_IOS::in || which == BOOST_IOS::out);
#else
- if (which == (BOOST_IOS::in | BOOST_IOS::out)) {
- detail::close_all(t, snk);
- return;
- }
+ if (which == (BOOST_IOS::in | BOOST_IOS::out)) {
+ detail::close_all(t, snk);
+ return;
+ }
#endif
detail::close_impl<T>::close(detail::unwrap(t), snk, which);
}
Modified: branches/release/boost/iostreams/filter/newline.hpp
==============================================================================
--- branches/release/boost/iostreams/filter/newline.hpp (original)
+++ branches/release/boost/iostreams/filter/newline.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -20,7 +20,7 @@
#include <stdexcept> // logic_error.
#include <boost/config.hpp> // BOOST_STATIC_CONSTANT.
#include <boost/iostreams/categories.hpp>
-#include <boost/iostreams/detail/char_traits.hpp>
+#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/ios.hpp> // BOOST_IOSTREAMS_FAILURE
#include <boost/iostreams/read.hpp> // get
#include <boost/iostreams/write.hpp> // put
Modified: branches/release/boost/math/special_functions/detail/fp_traits.hpp
==============================================================================
--- branches/release/boost/math/special_functions/detail/fp_traits.hpp (original)
+++ branches/release/boost/math/special_functions/detail/fp_traits.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -242,7 +242,7 @@
#endif
-#endif // #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
+#endif // #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
// long double (64 bits) -------------------------------------------------------
Modified: branches/release/boost/math/special_functions/fpclassify.hpp
==============================================================================
--- branches/release/boost/math/special_functions/fpclassify.hpp (original)
+++ branches/release/boost/math/special_functions/fpclassify.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -45,8 +45,8 @@
Otherwise the number is normal.
- This algorithm works for the IEEE 754 representation,
- and also for several non IEEE 754 formats.
+ This algorithm works for the IEEE 754 representation,
+ and also for several non IEEE 754 formats.
Most formats have the structure
sign bit + exponent bits + significand bits.
@@ -54,8 +54,8 @@
A few have the structure
sign bit + exponent bits + flag bit + significand bits.
The flag bit is 0 for zero and subnormal numbers,
- and 1 for normal numbers and NaN.
- It is 0 (Motorola 68K) or 1 (Intel) for infinity.
+ and 1 for normal numbers and NaN.
+ It is 0 (Motorola 68K) or 1 (Intel) for infinity.
To get the bits, the four or eight most significant bytes are copied
into an uint32_t or uint64_t and bit masks are applied.
Modified: branches/release/boost/numeric/ublas/detail/concepts.hpp
==============================================================================
--- branches/release/boost/numeric/ublas/detail/concepts.hpp (original)
+++ branches/release/boost/numeric/ublas/detail/concepts.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -969,7 +969,7 @@
}
#endif
-#if defined (VECTOR_VIEW)
+#if defined (VECTOR_VIEW)
// read only vectors
{
typedef vector_view<T> container_model;
Modified: branches/release/boost/numeric/ublas/functional.hpp
==============================================================================
--- branches/release/boost/numeric/ublas/functional.hpp (original)
+++ branches/release/boost/numeric/ublas/functional.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -446,7 +446,7 @@
size_type size (e ().size ());
for (size_type i = 0; i < size; ++ i) {
real_type u (type_traits<value_type>::norm_2 (e () (i)));
- if ( real_type () /* zero */ == u ) continue;
+ if ( real_type () /* zero */ == u ) continue;
if (scale < u) {
real_type v (scale / u);
sum_squares = sum_squares * v * v + real_type (1);
@@ -1727,7 +1727,7 @@
bool other (size_type /* i */, size_type /* j */) {
return true;
}
- // FIXME: this should not be used at all
+ // FIXME: this should not be used at all
static
BOOST_UBLAS_INLINE
size_type restrict1 (size_type i, size_type j) {
@@ -1751,81 +1751,81 @@
};
namespace detail {
- template < class L >
- struct transposed_structure {
- typedef typename L::size_type size_type;
-
- template<class LAYOUT>
- static
- BOOST_UBLAS_INLINE
- size_type packed_size (LAYOUT l, size_type size_i, size_type size_j) {
- return L::packed_size(l, size_j, size_i);
- }
-
- static
- BOOST_UBLAS_INLINE
- bool zero (size_type i, size_type j) {
- return L::zero(j, i);
- }
- static
- BOOST_UBLAS_INLINE
- bool one (size_type i, size_type j) {
- return L::one(j, i);
- }
- static
- BOOST_UBLAS_INLINE
- bool other (size_type i, size_type j) {
- return L::other(j, i);
- }
- template<class LAYOUT>
- static
- BOOST_UBLAS_INLINE
- size_type element (LAYOUT l, size_type i, size_type size_i, size_type j, size_type size_j) {
- return L::element(typename LAYOUT::transposed_layout(), j, size_j, i, size_i);
- }
-
- static
- BOOST_UBLAS_INLINE
- size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
- return L::restrict2(j, i, size2, size1);
- }
- static
- BOOST_UBLAS_INLINE
- size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
- return L::restrict1(j, i, size2, size1);
- }
- static
- BOOST_UBLAS_INLINE
- size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
- return L::mutable_restrict2(j, i, size2, size1);
- }
- static
- BOOST_UBLAS_INLINE
- size_type mutable_restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
- return L::mutable_restrict1(j, i, size2, size1);
- }
-
- static
- BOOST_UBLAS_INLINE
- size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return L::global_restrict2(index2, size2, index1, size1);
- }
- static
- BOOST_UBLAS_INLINE
- size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return L::global_restrict1(index2, size2, index1, size1);
- }
- static
- BOOST_UBLAS_INLINE
- size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return L::global_mutable_restrict2(index2, size2, index1, size1);
- }
- static
- BOOST_UBLAS_INLINE
- size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return L::global_mutable_restrict1(index2, size2, index1, size1);
- }
- };
+ template < class L >
+ struct transposed_structure {
+ typedef typename L::size_type size_type;
+
+ template<class LAYOUT>
+ static
+ BOOST_UBLAS_INLINE
+ size_type packed_size (LAYOUT l, size_type size_i, size_type size_j) {
+ return L::packed_size(l, size_j, size_i);
+ }
+
+ static
+ BOOST_UBLAS_INLINE
+ bool zero (size_type i, size_type j) {
+ return L::zero(j, i);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ bool one (size_type i, size_type j) {
+ return L::one(j, i);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ bool other (size_type i, size_type j) {
+ return L::other(j, i);
+ }
+ template<class LAYOUT>
+ static
+ BOOST_UBLAS_INLINE
+ size_type element (LAYOUT l, size_type i, size_type size_i, size_type j, size_type size_j) {
+ return L::element(typename LAYOUT::transposed_layout(), j, size_j, i, size_i);
+ }
+
+ static
+ BOOST_UBLAS_INLINE
+ size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
+ return L::restrict2(j, i, size2, size1);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
+ return L::restrict1(j, i, size2, size1);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
+ return L::mutable_restrict2(j, i, size2, size1);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ size_type mutable_restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
+ return L::mutable_restrict1(j, i, size2, size1);
+ }
+
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return L::global_restrict2(index2, size2, index1, size1);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return L::global_restrict1(index2, size2, index1, size1);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return L::global_mutable_restrict2(index2, size2, index1, size1);
+ }
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return L::global_mutable_restrict1(index2, size2, index1, size1);
+ }
+ };
}
template <class Z>
@@ -1862,56 +1862,56 @@
return L::lower_element (i, size_i, j, size_j);
}
- // return nearest valid index in column j
+ // return nearest valid index in column j
static
BOOST_UBLAS_INLINE
size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
return (std::max)(j, (std::min) (size1, i));
}
- // return nearest valid index in row i
+ // return nearest valid index in row i
static
BOOST_UBLAS_INLINE
size_type restrict2 (size_type i, size_type j, size_type /* size1 */, size_type /* size2 */) {
return (std::max)(size_type(0), (std::min) (i+1, j));
}
- // return nearest valid mutable index in column j
+ // return nearest valid mutable index in column j
static
BOOST_UBLAS_INLINE
size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
return (std::max)(j, (std::min) (size1, i));
}
- // return nearest valid mutable index in row i
+ // return nearest valid mutable index in row i
static
BOOST_UBLAS_INLINE
size_type mutable_restrict2 (size_type i, size_type j, size_type /* size1 */, size_type /* size2 */) {
return (std::max)(size_type(0), (std::min) (i+1, j));
}
- // return an index between the first and (1+last) filled row
- static
- BOOST_UBLAS_INLINE
- size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return (std::max)(size_type(0), (std::min)(size1, index1) );
- }
- // return an index between the first and (1+last) filled column
- static
- BOOST_UBLAS_INLINE
- size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return (std::max)(size_type(0), (std::min)(size2, index2) );
- }
-
- // return an index between the first and (1+last) filled mutable row
- static
- BOOST_UBLAS_INLINE
- size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return (std::max)(size_type(0), (std::min)(size1, index1) );
- }
- // return an index between the first and (1+last) filled mutable column
- static
- BOOST_UBLAS_INLINE
- size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return (std::max)(size_type(0), (std::min)(size2, index2) );
- }
+ // return an index between the first and (1+last) filled row
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return (std::max)(size_type(0), (std::min)(size1, index1) );
+ }
+ // return an index between the first and (1+last) filled column
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return (std::max)(size_type(0), (std::min)(size2, index2) );
+ }
+
+ // return an index between the first and (1+last) filled mutable row
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return (std::max)(size_type(0), (std::min)(size1, index1) );
+ }
+ // return an index between the first and (1+last) filled mutable column
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return (std::max)(size_type(0), (std::min)(size2, index2) );
+ }
};
// the first row only contains a single 1. Thus it is not stored.
@@ -1959,19 +1959,19 @@
return (std::max)(size_type(0), (std::min) (i, j));
}
- // return an index between the first and (1+last) filled mutable row
- static
- BOOST_UBLAS_INLINE
- size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return (std::max)(size_type(1), (std::min)(size1, index1) );
- }
- // return an index between the first and (1+last) filled mutable column
- static
- BOOST_UBLAS_INLINE
- size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
- BOOST_UBLAS_CHECK( size2 >= 1 , external_logic() );
- return (std::max)(size_type(0), (std::min)(size2-1, index2) );
- }
+ // return an index between the first and (1+last) filled mutable row
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return (std::max)(size_type(1), (std::min)(size1, index1) );
+ }
+ // return an index between the first and (1+last) filled mutable column
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ BOOST_UBLAS_CHECK( size2 >= 1 , external_logic() );
+ return (std::max)(size_type(0), (std::min)(size2-1, index2) );
+ }
};
// the first row only contains no element. Thus it is not stored.
@@ -2016,26 +2016,26 @@
static
BOOST_UBLAS_INLINE
size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2) {
- return mutable_restrict1(i, j, size1, size2);
+ return mutable_restrict1(i, j, size1, size2);
}
static
BOOST_UBLAS_INLINE
size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2) {
- return mutable_restrict2(i, j, size1, size2);
+ return mutable_restrict2(i, j, size1, size2);
}
- // return an index between the first and (1+last) filled row
- static
- BOOST_UBLAS_INLINE
- size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return global_mutable_restrict1(index1, size1, index2, size2);
- }
- // return an index between the first and (1+last) filled column
- static
- BOOST_UBLAS_INLINE
- size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
- return global_mutable_restrict2(index1, size1, index2, size2);
- }
+ // return an index between the first and (1+last) filled row
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return global_mutable_restrict1(index1, size1, index2, size2);
+ }
+ // return an index between the first and (1+last) filled column
+ static
+ BOOST_UBLAS_INLINE
+ size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2) {
+ return global_mutable_restrict2(index1, size1, index2, size2);
+ }
};
Modified: branches/release/boost/numeric/ublas/triangular.hpp
==============================================================================
--- branches/release/boost/numeric/ublas/triangular.hpp (original)
+++ branches/release/boost/numeric/ublas/triangular.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -296,32 +296,32 @@
const_iterator1 find1 (int rank, size_type i, size_type j) const {
if (rank == 1)
i = triangular_type::restrict1 (i, j, size1_, size2_);
- if (rank == 0)
- i = triangular_type::global_restrict1 (i, size1_, j, size2_);
+ if (rank == 0)
+ i = triangular_type::global_restrict1 (i, size1_, j, size2_);
return const_iterator1 (*this, i, j);
}
BOOST_UBLAS_INLINE
iterator1 find1 (int rank, size_type i, size_type j) {
if (rank == 1)
i = triangular_type::mutable_restrict1 (i, j, size1_, size2_);
- if (rank == 0)
- i = triangular_type::global_mutable_restrict1 (i, size1_, j, size2_);
+ if (rank == 0)
+ i = triangular_type::global_mutable_restrict1 (i, size1_, j, size2_);
return iterator1 (*this, i, j);
}
BOOST_UBLAS_INLINE
const_iterator2 find2 (int rank, size_type i, size_type j) const {
if (rank == 1)
j = triangular_type::restrict2 (i, j, size1_, size2_);
- if (rank == 0)
- j = triangular_type::global_restrict2 (i, size1_, j, size2_);
+ if (rank == 0)
+ j = triangular_type::global_restrict2 (i, size1_, j, size2_);
return const_iterator2 (*this, i, j);
}
BOOST_UBLAS_INLINE
iterator2 find2 (int rank, size_type i, size_type j) {
if (rank == 1)
j = triangular_type::mutable_restrict2 (i, j, size1_, size2_);
- if (rank == 0)
- j = triangular_type::global_mutable_restrict2 (i, size1_, j, size2_);
+ if (rank == 0)
+ j = triangular_type::global_mutable_restrict2 (i, size1_, j, size2_);
return iterator2 (*this, i, j);
}
@@ -1153,33 +1153,33 @@
BOOST_UBLAS_INLINE
const_iterator1 find1 (int rank, size_type i, size_type j) const {
if (rank == 1)
- i = triangular_type::restrict1 (i, j, size1(), size2());
- if (rank == 0)
- i = triangular_type::global_restrict1 (i, size1(), j, size2());
+ i = triangular_type::restrict1 (i, j, size1(), size2());
+ if (rank == 0)
+ i = triangular_type::global_restrict1 (i, size1(), j, size2());
return const_iterator1 (*this, data ().find1 (rank, i, j));
}
BOOST_UBLAS_INLINE
iterator1 find1 (int rank, size_type i, size_type j) {
if (rank == 1)
i = triangular_type::mutable_restrict1 (i, j, size1(), size2());
- if (rank == 0)
- i = triangular_type::global_mutable_restrict1 (i, size1(), j, size2());
+ if (rank == 0)
+ i = triangular_type::global_mutable_restrict1 (i, size1(), j, size2());
return iterator1 (*this, data ().find1 (rank, i, j));
}
BOOST_UBLAS_INLINE
const_iterator2 find2 (int rank, size_type i, size_type j) const {
if (rank == 1)
j = triangular_type::restrict2 (i, j, size1(), size2());
- if (rank == 0)
- j = triangular_type::global_restrict2 (i, size1(), j, size2());
+ if (rank == 0)
+ j = triangular_type::global_restrict2 (i, size1(), j, size2());
return const_iterator2 (*this, data ().find2 (rank, i, j));
}
BOOST_UBLAS_INLINE
iterator2 find2 (int rank, size_type i, size_type j) {
if (rank == 1)
j = triangular_type::mutable_restrict2 (i, j, size1(), size2());
- if (rank == 0)
- j = triangular_type::global_mutable_restrict2 (i, size1(), j, size2());
+ if (rank == 0)
+ j = triangular_type::global_mutable_restrict2 (i, size1(), j, size2());
return iterator2 (*this, data ().find2 (rank, i, j));
}
Modified: branches/release/boost/pending/fibonacci_heap.hpp
==============================================================================
--- branches/release/boost/pending/fibonacci_heap.hpp (original)
+++ branches/release/boost/pending/fibonacci_heap.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -193,7 +193,7 @@
}
if (_mark[p] == false) {
_mark[p] = true;
- --_degree[p];
+ --_degree[p];
break;
} else
--_degree[p];
Modified: branches/release/boost/pool/pool_alloc.hpp
==============================================================================
--- branches/release/boost/pool/pool_alloc.hpp (original)
+++ branches/release/boost/pool/pool_alloc.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -65,7 +65,7 @@
// initialization. See ticket #2359 for a complete explaination
// ( http://svn.boost.org/trac/boost/ticket/2359 )
singleton_pool<pool_allocator_tag, sizeof(T), UserAllocator, Mutex,
- NextSize>::is_from(0);
+ NextSize>::is_from(0);
}
// default copy constructor
@@ -81,7 +81,7 @@
// initialization. See ticket #2359 for a complete explaination
// ( http://svn.boost.org/trac/boost/ticket/2359 )
singleton_pool<pool_allocator_tag, sizeof(T), UserAllocator, Mutex,
- NextSize>::is_from(0);
+ NextSize>::is_from(0);
}
// default destructor
@@ -138,7 +138,7 @@
typedef const void* const_pointer;
typedef void value_type;
template <class U> struct rebind {
- typedef pool_allocator<U, UserAllocator, Mutex, NextSize> other;
+ typedef pool_allocator<U, UserAllocator, Mutex, NextSize> other;
};
};
@@ -177,7 +177,7 @@
// initialization. See ticket #2359 for a complete explaination
// ( http://svn.boost.org/trac/boost/ticket/2359 )
singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::is_from(0);
+ UserAllocator, Mutex, NextSize>::is_from(0);
}
// default copy constructor
@@ -194,7 +194,7 @@
// initialization. See ticket #2359 for a complete explaination
// ( http://svn.boost.org/trac/boost/ticket/2359 )
singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::is_from(0);
+ UserAllocator, Mutex, NextSize>::is_from(0);
}
// default destructor
@@ -228,7 +228,7 @@
singleton_pool<fast_pool_allocator_tag, sizeof(T),
UserAllocator, Mutex, NextSize>::ordered_malloc(n) );
if (ret == 0)
- boost::throw_exception(std::bad_alloc());
+ boost::throw_exception(std::bad_alloc());
return ret;
}
static pointer allocate(const size_type n, const void * const)
@@ -239,7 +239,7 @@
singleton_pool<fast_pool_allocator_tag, sizeof(T),
UserAllocator, Mutex, NextSize>::malloc() );
if (ret == 0)
- boost::throw_exception(std::bad_alloc());
+ boost::throw_exception(std::bad_alloc());
return ret;
}
static void deallocate(const pointer ptr, const size_type n)
@@ -273,7 +273,7 @@
typedef const void* const_pointer;
typedef void value_type;
template <class U> struct rebind {
- typedef fast_pool_allocator<U, UserAllocator, Mutex, NextSize> other;
+ typedef fast_pool_allocator<U, UserAllocator, Mutex, NextSize> other;
};
};
Modified: branches/release/boost/program_options/positional_options.hpp
==============================================================================
--- branches/release/boost/program_options/positional_options.hpp (original)
+++ branches/release/boost/program_options/positional_options.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -41,7 +41,7 @@
add(const char* name, int max_count);
/** Returns the maximum number of positional options that can
- be present. Can return numeric_limits<unsigned>::max() to
+ be present. Can return (numeric_limits<unsigned>::max)() to
indicate unlimited number. */
unsigned max_total_count() const;
Modified: branches/release/boost/python/enum.hpp
==============================================================================
--- branches/release/boost/python/enum.hpp (original)
+++ branches/release/boost/python/enum.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -41,7 +41,7 @@
, &enum_<T>::convertible_from_python
, &enum_<T>::construct
, type_id<T>()
- , doc
+ , doc
)
{
}
Modified: branches/release/boost/python/make_constructor.hpp
==============================================================================
--- branches/release/boost/python/make_constructor.hpp (original)
+++ branches/release/boost/python/make_constructor.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -105,12 +105,12 @@
// If the BasePolicy_ supplied a result converter it would be
// ignored; issue an error if it's not the default.
#if defined _MSC_VER && _MSC_VER < 1300
- typedef is_same<
+ typedef is_same<
typename BasePolicy_::result_converter
, default_result_converter
> same_result_converter;
- //see above for explanation
- BOOST_STATIC_ASSERT(same_result_converter::value) ;
+ //see above for explanation
+ BOOST_STATIC_ASSERT(same_result_converter::value) ;
#else
BOOST_MPL_ASSERT_MSG(
(is_same<
Modified: branches/release/boost/random/uniform_int.hpp
==============================================================================
--- branches/release/boost/random/uniform_int.hpp (original)
+++ branches/release/boost/random/uniform_int.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -152,7 +152,7 @@
// use rejection method to handle cases like 0..5 -> 0..4
for(;;) {
base_unsigned result =
- random::detail::subtract<base_result>()(eng(), bmin);
+ random::detail::subtract<base_result>()(eng(), bmin);
// result and range are non-negative, and result is possibly larger
// than range, so the cast is safe
if(result <= static_cast<base_unsigned>(range))
Modified: branches/release/boost/test/impl/unit_test_parameters.ipp
==============================================================================
--- branches/release/boost/test/impl/unit_test_parameters.ipp (original)
+++ branches/release/boost/test/impl/unit_test_parameters.ipp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -25,6 +25,22 @@
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/test/utils/fixed_mapping.hpp>
#include <boost/test/debug.hpp>
+#include <boost/test/framework.hpp>
+
+// Boost.Runtime.Param
+#include <boost/test/utils/runtime/cla/dual_name_parameter.hpp>
+#include <boost/test/utils/runtime/cla/parser.hpp>
+
+namespace rt = boost::runtime;
+namespace cla = rt::cla;
+
+
+#ifndef UNDER_CE
+#include <boost/test/utils/runtime/env/variable.hpp>
+
+namespace env = rt::env;
+#endif
+
// Boost
#include <boost/config.hpp>
@@ -35,6 +51,7 @@
// STL
#include <map>
#include <cstdlib>
+#include <iostream>
#include <boost/test/detail/suppress_warnings.hpp>
@@ -48,130 +65,14 @@
namespace unit_test {
-namespace {
-
-// framework parameters and there corresponding command-line arguments
-literal_string LOG_LEVEL = "BOOST_TEST_LOG_LEVEL";
-literal_string NO_RESULT_CODE = "BOOST_TEST_RESULT_CODE";
-literal_string REPORT_LEVEL = "BOOST_TEST_REPORT_LEVEL";
-literal_string TESTS_TO_RUN = "BOOST_TESTS_TO_RUN";
-literal_string SAVE_TEST_PATTERN = "BOOST_TEST_SAVE_PATTERN";
-literal_string BUILD_INFO = "BOOST_TEST_BUILD_INFO";
-literal_string SHOW_PROGRESS = "BOOST_TEST_SHOW_PROGRESS";
-literal_string CATCH_SYS_ERRORS = "BOOST_TEST_CATCH_SYSTEM_ERRORS";
-literal_string AUTO_START_DBG = "BOOST_TEST_AUTO_START_DBG";
-literal_string USE_ALT_STACK = "BOOST_TEST_USE_ALT_STACK";
-literal_string DETECT_FP_EXCEPT = "BOOST_TEST_DETECT_FP_EXCEPTIONS";
-literal_string REPORT_FORMAT = "BOOST_TEST_REPORT_FORMAT";
-literal_string LOG_FORMAT = "BOOST_TEST_LOG_FORMAT";
-literal_string OUTPUT_FORMAT = "BOOST_TEST_OUTPUT_FORMAT";
-literal_string DETECT_MEM_LEAK = "BOOST_TEST_DETECT_MEMORY_LEAK";
-literal_string RANDOM_SEED = "BOOST_TEST_RANDOM";
-literal_string BREAK_EXEC_PATH = "BOOST_TEST_BREAK_EXEC_PATH";
-
-unit_test::log_level s_log_level;
-bool s_no_result_code;
-unit_test::report_level s_report_level;
-const_string s_tests_to_run;
-const_string s_exec_path_to_break;
-bool s_save_pattern;
-bool s_show_build_info;
-bool s_show_progress;
-bool s_catch_sys_errors;
-bool s_auto_start_dbg;
-bool s_use_alt_stack;
-bool s_detect_fp_except;
-output_format s_report_format;
-output_format s_log_format;
-long s_detect_mem_leaks;
-unsigned int s_random_seed;
-
// ************************************************************************** //
-// ************** runtime_config ************** //
+// ************** input operations for unit_test's enums ************** //
// ************************************************************************** //
-const_string
-retrieve_framework_parameter( const_string parameter_name, int* argc, char** argv )
+std::istream&
+operator>>( std::istream& in, unit_test::log_level& ll )
{
- static fixed_mapping<const_string,const_string> parameter_2_cla_name_map(
- LOG_LEVEL , "--log_level",
- NO_RESULT_CODE , "--result_code",
- REPORT_LEVEL , "--report_level",
- TESTS_TO_RUN , "--run_test",
- SAVE_TEST_PATTERN , "--save_pattern",
- BUILD_INFO , "--build_info",
- SHOW_PROGRESS , "--show_progress",
- CATCH_SYS_ERRORS , "--catch_system_errors",
- AUTO_START_DBG , "--auto_start_dbg",
- USE_ALT_STACK , "--use_alt_stack",
- DETECT_FP_EXCEPT , "--detect_fp_exceptions",
- REPORT_FORMAT , "--report_format",
- LOG_FORMAT , "--log_format",
- OUTPUT_FORMAT , "--output_format",
- DETECT_MEM_LEAK , "--detect_memory_leaks",
- RANDOM_SEED , "--random",
- BREAK_EXEC_PATH , "--break_exec_path",
-
- ""
- );
-
- // first try to find parameter among command line arguments if present
- if( argc ) {
- // locate corresponding cla name
- const_string cla_name = parameter_2_cla_name_map[parameter_name];
-
- if( !cla_name.is_empty() ) {
- for( int i = 1; i < *argc; ++i ) {
- if( cla_name == const_string( argv[i], cla_name.size() ) && argv[i][cla_name.size()] == '=' ) {
- const_string result = argv[i] + cla_name.size() + 1;
-
- for( int j = i; j < *argc; ++j ) {
- argv[j] = argv[j+1];
- }
- --(*argc);
-
- return result;
- }
- }
- }
- }
-
- return std::getenv( parameter_name.begin() );
-}
-
-long interpret_long( const_string from )
-{
- bool negative = false;
- long res = 0;
-
- if( first_char( from ) == '-' ) {
- negative = true;
- from.trim_left( 1 );
- }
-
- const_string::iterator it = from.begin();
- for( ;it != from.end(); ++it ) {
- int d = *it - '0';
-
- res = 10 * res + d;
- }
-
- if( negative )
- res = -res;
-
- return res;
-}
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-namespace runtime_config {
-
-void
-init( int* argc, char** argv )
-{
- fixed_mapping<const_string,unit_test::log_level,case_ins_less<char const> > log_level_name(
+ static fixed_mapping<const_string,unit_test::log_level,case_ins_less<char const> > log_level_name(
"all" , log_successful_tests,
"success" , log_successful_tests,
"test_suite" , log_test_units,
@@ -185,8 +86,22 @@
"nothing" , log_nothing,
invalid_log_level
- );
+ );
+
+ std::string val;
+ in >> val;
+
+ ll = log_level_name[val];
+ BOOST_TEST_SETUP_ASSERT( ll != unit_test::invalid_log_level, "invalid log level " + val );
+
+ return in;
+}
+//____________________________________________________________________________//
+
+std::istream&
+operator>>( std::istream& in, unit_test::report_level& rl )
+{
fixed_mapping<const_string,unit_test::report_level,case_ins_less<char const> > report_level_name (
"confirm", CONFIRMATION_REPORT,
"short", SHORT_REPORT,
@@ -194,57 +109,215 @@
"no", NO_REPORT,
INV_REPORT_LEVEL
- );
+ );
- fixed_mapping<const_string,output_format,case_ins_less<char const> > output_format_name (
- "HRF", CLF,
- "CLF", CLF,
- "XML", XML,
-
- CLF
- );
-
- s_no_result_code = retrieve_framework_parameter( NO_RESULT_CODE, argc, argv ) == "no";
- s_save_pattern = retrieve_framework_parameter( SAVE_TEST_PATTERN, argc, argv ) == "yes";
- s_show_build_info = retrieve_framework_parameter( BUILD_INFO, argc, argv ) == "yes";
- s_show_progress = retrieve_framework_parameter( SHOW_PROGRESS, argc, argv ) == "yes";
-#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
- s_catch_sys_errors = retrieve_framework_parameter( CATCH_SYS_ERRORS, argc, argv ) == "yes";
-#else
- s_catch_sys_errors = retrieve_framework_parameter( CATCH_SYS_ERRORS, argc, argv ) != "no";
-#endif
- s_use_alt_stack = retrieve_framework_parameter( USE_ALT_STACK, argc, argv ) != "no";
- s_detect_fp_except = retrieve_framework_parameter( DETECT_FP_EXCEPT, argc, argv ) == "yes";
- s_tests_to_run = retrieve_framework_parameter( TESTS_TO_RUN, argc, argv );
- s_exec_path_to_break= retrieve_framework_parameter( BREAK_EXEC_PATH, argc, argv );
-
- const_string rs_str = retrieve_framework_parameter( RANDOM_SEED, argc, argv );
- s_random_seed = rs_str.is_empty() ? 0 : lexical_cast<unsigned int>( rs_str );
-
- s_log_level = log_level_name[retrieve_framework_parameter( LOG_LEVEL, argc, argv )];
- s_report_level = report_level_name[retrieve_framework_parameter( REPORT_LEVEL, argc, argv )];
-
- s_report_format = output_format_name[retrieve_framework_parameter( REPORT_FORMAT, argc, argv )];
- s_log_format = output_format_name[retrieve_framework_parameter( LOG_FORMAT, argc, argv )];
-
- const_string output_format = retrieve_framework_parameter( OUTPUT_FORMAT, argc, argv );
- if( !output_format.is_empty() ) {
- s_report_format = output_format_name[output_format];
- s_log_format = output_format_name[output_format];
+ std::string val;
+ in >> val;
+
+ rl = report_level_name[val];
+ BOOST_TEST_SETUP_ASSERT( rl != INV_REPORT_LEVEL, "invalid report level " + val );
+
+ return in;
+}
+
+//____________________________________________________________________________//
+
+std::istream&
+operator>>( std::istream& in, unit_test::output_format& of )
+{
+ fixed_mapping<const_string,unit_test::output_format,case_ins_less<char const> > output_format_name (
+ "HRF", unit_test::CLF,
+ "CLF", unit_test::CLF,
+ "XML", unit_test::XML,
+
+ unit_test::INV_OF
+ );
+
+ std::string val;
+ in >> val;
+
+ of = output_format_name[val];
+ BOOST_TEST_SETUP_ASSERT( of != unit_test::INV_OF, "invalid output format " + val );
+
+ return in;
+}
+
+//____________________________________________________________________________//
+
+// ************************************************************************** //
+// ************** runtime_config ************** //
+// ************************************************************************** //
+
+namespace runtime_config {
+
+namespace {
+
+// framework parameters and corresponding command-line arguments
+std::string AUTO_START_DBG = "auto_start_dbg";
+std::string BREAK_EXEC_PATH = "break_exec_path";
+std::string BUILD_INFO = "build_info";
+std::string CATCH_SYS_ERRORS = "catch_system_errors";
+std::string DETECT_FP_EXCEPT = "detect_fp_exceptions";
+std::string DETECT_MEM_LEAKS = "detect_memory_leaks";
+std::string LOG_FORMAT = "log_format";
+std::string LOG_LEVEL = "log_level";
+std::string OUTPUT_FORMAT = "output_format";
+std::string RANDOM_SEED = "random";
+std::string REPORT_FORMAT = "report_format";
+std::string REPORT_LEVEL = "report_level";
+std::string RESULT_CODE = "result_code";
+std::string TESTS_TO_RUN = "run_test";
+std::string SAVE_TEST_PATTERN = "save_pattern";
+std::string SHOW_PROGRESS = "show_progress";
+std::string USE_ALT_STACK = "use_alt_stack";
+
+fixed_mapping<const_string,const_string> parameter_2_env_var(
+ AUTO_START_DBG , "BOOST_TEST_AUTO_START_DBG",
+ BREAK_EXEC_PATH , "BOOST_TEST_BREAK_EXEC_PATH",
+ BUILD_INFO , "BOOST_TEST_BUILD_INFO",
+ CATCH_SYS_ERRORS , "BOOST_TEST_CATCH_SYSTEM_ERRORS",
+ DETECT_FP_EXCEPT , "BOOST_TEST_DETECT_FP_EXCEPTIONS",
+ DETECT_MEM_LEAKS , "BOOST_TEST_DETECT_MEMORY_LEAK",
+ LOG_FORMAT , "BOOST_TEST_LOG_FORMAT",
+ LOG_LEVEL , "BOOST_TEST_LOG_LEVEL",
+ OUTPUT_FORMAT , "BOOST_TEST_OUTPUT_FORMAT",
+ RANDOM_SEED , "BOOST_TEST_RANDOM",
+ REPORT_FORMAT , "BOOST_TEST_REPORT_FORMAT",
+ REPORT_LEVEL , "BOOST_TEST_REPORT_LEVEL",
+ RESULT_CODE , "BOOST_TEST_RESULT_CODE",
+ TESTS_TO_RUN , "BOOST_TESTS_TO_RUN",
+ SAVE_TEST_PATTERN , "BOOST_TEST_SAVE_PATTERN",
+ SHOW_PROGRESS , "BOOST_TEST_SHOW_PROGRESS",
+ USE_ALT_STACK , "BOOST_TEST_USE_ALT_STACK",
+
+ ""
+);
+
+//____________________________________________________________________________//
+
+// storage for the CLAs
+cla::parser s_cla_parser;
+std::string s_empty;
+
+output_format s_report_format;
+output_format s_log_format;
+
+//____________________________________________________________________________//
+
+template<typename T>
+T
+retrieve_parameter( const_string parameter_name, cla::parser const& s_cla_parser, T const& default_value = T(), T const& optional_value = T() )
+{
+ rt::const_argument_ptr arg = s_cla_parser[parameter_name];
+ if( arg ) {
+ if( rtti::type_id<T>() == rtti::type_id<bool>() ||
+ !static_cast<cla::parameter const&>( arg->p_formal_parameter.get() ).p_optional_value )
+ return s_cla_parser.get<T>( parameter_name );
+
+ optional<T> val = s_cla_parser.get<optional<T> >( parameter_name );
+ return val ? *val : optional_value;
}
- const_string ml_str = retrieve_framework_parameter( DETECT_MEM_LEAK, argc, argv );
- s_detect_mem_leaks = ml_str.is_empty() ? 1 : interpret_long( ml_str );
+ boost::optional<T> v;
+
+ #ifndef UNDER_CE
+ env::get( parameter_2_env_var[parameter_name], v );
+ #endif
+
+ return v? *v : default_value;
+}
+
+//____________________________________________________________________________//
+
+} // local namespace
+
+void
+init( int& argc, char** argv )
+{
+ using namespace cla;
+
+ try {
+ s_cla_parser - cla::ignore_mismatch
+ << cla::dual_name_parameter<bool>( AUTO_START_DBG + "|d" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Automatically starts debugger if system level error (signal) occurs")
+ << cla::named_parameter<std::string>( BREAK_EXEC_PATH )
+ - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
+ cla::description = "For the exception safety testing allows to break at specific execution path")
+ << cla::dual_name_parameter<bool>( BUILD_INFO + "|i" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Shows library build information" )
+ << cla::dual_name_parameter<bool>( CATCH_SYS_ERRORS + "|s" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Allows to switch between catching and ignoring system errors (signals)")
+ << cla::named_parameter<bool>( DETECT_FP_EXCEPT )
+ - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
+ cla::description = "Allows to switch between catching and ignoring floating point exceptions")
+ << cla::named_parameter<long>( DETECT_MEM_LEAKS )
+ - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
+ cla::description = "Allows to switch between catching and ignoring memory leaks")
+ << cla::dual_name_parameter<unit_test::output_format>( LOG_FORMAT + "|f" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Specifies log format")
+ << cla::dual_name_parameter<unit_test::log_level>( LOG_LEVEL + "|l" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Specifies log level")
+ << cla::dual_name_parameter<unit_test::output_format>( OUTPUT_FORMAT + "|o" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Specifies output format (both log and report)")
+ << cla::dual_name_parameter<int>( RANDOM_SEED + "|a" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,cla::optional_value,
+ cla::description = "Allows to switch between sequential and random order of test units execution.\n"
+ "Optionally allows to specify concrete seed for random number generator")
+ << cla::dual_name_parameter<unit_test::output_format>( REPORT_FORMAT + "|m" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Specifies report format")
+ << cla::dual_name_parameter<unit_test::report_level>(REPORT_LEVEL + "|r")
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Specifies report level")
+ << cla::dual_name_parameter<bool>( RESULT_CODE + "|c" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Allows to disable test modules's result code generation")
+ << cla::dual_name_parameter<std::string>( TESTS_TO_RUN + "|t" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Allows to filter which test units to run")
+ << cla::named_parameter<bool>( SAVE_TEST_PATTERN )
+ - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
+ cla::description = "Allows to switch between saving and matching against test pattern file")
+ << cla::dual_name_parameter<bool>( SHOW_PROGRESS + "|p" )
+ - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
+ cla::description = "Turns on progress display")
+ << cla::named_parameter<bool>( USE_ALT_STACK )
+ - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
+ cla::description = "Turns on/off usage of an alternative stack for signal handling")
+
+ << cla::dual_name_parameter<bool>( "help|?" )
+ - (cla::prefix = "--|-",cla::separator = "=",cla::guess_name,cla::optional,
+ cla::description = "this help message")
+ ;
+
+ s_cla_parser.parse( argc, argv );
+
+ if( s_cla_parser["help"] ) {
+ s_cla_parser.help( std::cout );
+ throw framework::nothing_to_test();
+ }
+
+ s_report_format = retrieve_parameter( REPORT_FORMAT, s_cla_parser, unit_test::CLF );
+ s_log_format = retrieve_parameter( LOG_FORMAT, s_cla_parser, unit_test::CLF );
- const_string dbg = retrieve_framework_parameter( AUTO_START_DBG, argc, argv );
+ unit_test::output_format of = retrieve_parameter( OUTPUT_FORMAT, s_cla_parser, unit_test::INV_OF );
- if( dbg.is_empty() || dbg == "no" )
- s_auto_start_dbg = false;
- else {
- s_auto_start_dbg = true;
+ if( of != unit_test::INV_OF )
+ s_report_format = s_log_format = of;
+ }
+ catch( rt::logic_error const& ex ) {
+ std::ostringstream err;
+
+ err << "Fail to process runtime parameters: " << ex.msg() << std::endl;
+ s_cla_parser.usage( err );
- if( dbg != "yes" )
- debug::set_debugger( dbg );
+ throw framework::setup_error( err.str() );
}
}
@@ -253,7 +326,7 @@
unit_test::log_level
log_level()
{
- return s_log_level;
+ return retrieve_parameter( LOG_LEVEL, s_cla_parser, unit_test::log_all_errors );
}
//____________________________________________________________________________//
@@ -261,7 +334,7 @@
bool
no_result_code()
{
- return s_no_result_code;
+ return !retrieve_parameter( RESULT_CODE, s_cla_parser, true );
}
//____________________________________________________________________________//
@@ -269,7 +342,7 @@
unit_test::report_level
report_level()
{
- return s_report_level;
+ return retrieve_parameter( REPORT_LEVEL, s_cla_parser, unit_test::CONFIRMATION_REPORT );
}
//____________________________________________________________________________//
@@ -277,7 +350,9 @@
const_string
test_to_run()
{
- return s_tests_to_run;
+ static std::string s_test_to_run = retrieve_parameter( TESTS_TO_RUN, s_cla_parser, s_empty );
+
+ return s_test_to_run;
}
//____________________________________________________________________________//
@@ -285,7 +360,9 @@
const_string
break_exec_path()
{
- return s_exec_path_to_break;
+ static std::string s_break_exec_path = retrieve_parameter( BREAK_EXEC_PATH, s_cla_parser, s_empty );
+
+ return s_break_exec_path;
}
//____________________________________________________________________________//
@@ -293,7 +370,7 @@
bool
save_pattern()
{
- return s_save_pattern;
+ return retrieve_parameter( SAVE_TEST_PATTERN, s_cla_parser, false );
}
//____________________________________________________________________________//
@@ -301,7 +378,7 @@
bool
show_progress()
{
- return s_show_progress;
+ return retrieve_parameter( SHOW_PROGRESS, s_cla_parser, false );
}
//____________________________________________________________________________//
@@ -309,7 +386,7 @@
bool
show_build_info()
{
- return s_show_build_info;
+ return retrieve_parameter( BUILD_INFO, s_cla_parser, false );
}
//____________________________________________________________________________//
@@ -317,7 +394,13 @@
bool
catch_sys_errors()
{
- return s_catch_sys_errors;
+ return retrieve_parameter( CATCH_SYS_ERRORS, s_cla_parser,
+#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
+ false
+#else
+ true
+#endif
+ );
}
//____________________________________________________________________________//
@@ -325,7 +408,9 @@
bool
auto_start_dbg()
{
- return s_auto_start_dbg;
+ // !! set debugger as an option
+ return retrieve_parameter( AUTO_START_DBG, s_cla_parser, false );
+;
}
//____________________________________________________________________________//
@@ -333,7 +418,7 @@
bool
use_alt_stack()
{
- return s_use_alt_stack;
+ return retrieve_parameter( USE_ALT_STACK, s_cla_parser, true );
}
//____________________________________________________________________________//
@@ -341,7 +426,7 @@
bool
detect_fp_exceptions()
{
- return s_detect_fp_except;
+ return retrieve_parameter( DETECT_FP_EXCEPT, s_cla_parser, false );
}
//____________________________________________________________________________//
@@ -365,7 +450,7 @@
long
detect_memory_leaks()
{
- return s_detect_mem_leaks;
+ return retrieve_parameter( DETECT_MEM_LEAKS, s_cla_parser, (long)1 );
}
//____________________________________________________________________________//
@@ -373,7 +458,7 @@
int
random_seed()
{
- return s_random_seed;
+ return retrieve_parameter( RANDOM_SEED, s_cla_parser, 0, 1 );
}
//____________________________________________________________________________//
Modified: branches/release/boost/test/utils/runtime/file/config_file_iterator.cpp
==============================================================================
--- branches/release/boost/test/utils/runtime/file/config_file_iterator.cpp (original)
+++ branches/release/boost/test/utils/runtime/file/config_file_iterator.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -18,7 +18,10 @@
#include <boost/test/utils/runtime/file/config_file_iterator.hpp>
#include <boost/test/utils/runtime/validation.hpp>
+#ifndef UNDER_CE
#include <boost/test/utils/runtime/env/environment.hpp>
+#endif
+
// Boost
#include <boost/utility.hpp>
@@ -155,7 +158,7 @@
}
}
- BOOST_RT_PARAM_VALIDATE_LOGIC( m_stream.is_open(), BOOST_RT_PARAM_LITERAL( "couldn't open file " ) << file_name );
+ BOOST_RT_PARAM_VALIDATE_LOGIC( m_stream.is_open(), BOOST_RT_PARAM_LITERAL( "can't open file " ) << file_name );
}
//____________________________________________________________________________//
@@ -352,7 +355,9 @@
if( it == m_symbols_table.end() ) {
boost::optional<cstring> macro_value; // !! variable actually may have different type
+ #ifndef UNDER_CE
env::get( macro_name, macro_value );
+ #endif
BOOST_RT_PARAM_VALIDATE_LOGIC( macro_value || ignore_missing || !m_detect_missing_macro,
BOOST_RT_PARAM_LITERAL( "Unknown macro \"" ) << macro_name << BOOST_RT_PARAM_LITERAL( "\"" ) );
Modified: branches/release/boost/type_traits/alignment_of.hpp
==============================================================================
--- branches/release/boost/type_traits/alignment_of.hpp (original)
+++ branches/release/boost/type_traits/alignment_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -57,11 +57,11 @@
struct alignment_of_impl
{
#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
- //
- // With MSVC both the native __alignof operator
- // and our own logic gets things wrong from time to time :-(
- // Using a combination of the two seems to make the most of a bad job:
- //
+ //
+ // With MSVC both the native __alignof operator
+ // and our own logic gets things wrong from time to time :-(
+ // Using a combination of the two seems to make the most of a bad job:
+ //
BOOST_STATIC_CONSTANT(std::size_t, value =
(::boost::detail::alignment_logic<
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
Modified: branches/release/boost/utility/result_of.hpp
==============================================================================
--- branches/release/boost/utility/result_of.hpp (original)
+++ branches/release/boost/utility/result_of.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -70,8 +70,8 @@
template<typename F, typename FArgs>
struct result_of_impl<F, FArgs, false>
: mpl::if_<is_function_with_no_args<FArgs>,
- result_of_void_impl<F>,
- result_of_nested_result<F, FArgs> >::type
+ result_of_void_impl<F>,
+ result_of_nested_result<F, FArgs> >::type
{};
} // end namespace detail
Modified: branches/release/libs/accumulators/example/main.cpp
==============================================================================
--- branches/release/libs/accumulators/example/main.cpp (original)
+++ branches/release/libs/accumulators/example/main.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -54,7 +54,7 @@
// by value.
//std::for_each(data.begin(), data.end(), bind<void>(ref(acc), _1));
- std::cout << " min(acc) = " << (min)(acc) << std::endl;
+ std::cout << " min""(acc) = " << (min)(acc) << std::endl; // Extra quotes are to prevent complaints from Boost inspect tool
std::cout << " mean(acc) = " << mean(acc) << std::endl;
// since mean depends on count and sum, we can get their results, too.
Modified: branches/release/libs/interprocess/test/message_queue_test.cpp
==============================================================================
--- branches/release/libs/interprocess/test/message_queue_test.cpp (original)
+++ branches/release/libs/interprocess/test/message_queue_test.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -23,10 +23,6 @@
#include <string>
#include "get_process_id_name.hpp"
-#ifdef max
-#undef max
-#endif
-
////////////////////////////////////////////////////////////////////////////////
// //
// This example tests the process shared message queue. //
@@ -60,7 +56,7 @@
mq1.send(&tstamp, sizeof(tstamp), (unsigned int)(i%10));
}
- unsigned int priority_prev = std::numeric_limits<unsigned int>::max();
+ unsigned int priority_prev = (std::numeric_limits<unsigned int>::max)();
std::size_t tstamp_prev = 0;
//Receive all messages and test those are ordered
Modified: branches/release/libs/iostreams/src/file_descriptor.cpp
==============================================================================
--- branches/release/libs/iostreams/src/file_descriptor.cpp (original)
+++ branches/release/libs/iostreams/src/file_descriptor.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -229,7 +229,7 @@
throw detail::bad_seek();
} else {
return offset_to_position(
- (stream_offset(lDistanceToMoveHigh) << 32) + dwResultLow
+ (stream_offset(lDistanceToMoveHigh) << 32) + dwResultLow
);
}
#else // #ifdef BOOST_IOSTREAMS_WINDOWS
Modified: branches/release/libs/iostreams/src/mapped_file.cpp
==============================================================================
--- branches/release/libs/iostreams/src/mapped_file.cpp (original)
+++ branches/release/libs/iostreams/src/mapped_file.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -1,12 +1,7 @@
-// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
-// (C) Copyright 2004-2007 Jonathan Turkanis
// (C) Copyright Craig Henderson 2002 'boost/memmap.hpp' from sandbox
+// (C) Copyright Jonathan Turkanis 2004.
// (C) Copyright Jonathan Graehl 2004.
-
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
-
-// See http://www.boost.org/libs/iostreams for documentation.
+// (C) Copyright Jorge Lodos 2008.
// Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp>
// knows that we are building the library (possibly exporting code), rather
@@ -14,21 +9,15 @@
#define BOOST_IOSTREAMS_SOURCE
#include <cassert>
-#ifndef NDEBUG
-# include <boost/iostreams/detail/absolute_path.hpp>
-#endif
-#include <boost/iostreams/detail/config/dyn_link.hpp>
+#include <boost/iostreams/detail/config/rtl.hpp>
#include <boost/iostreams/detail/config/windows_posix.hpp>
-#include <boost/iostreams/detail/ios.hpp> // failure.
+#include <boost/iostreams/detail/file_handle.hpp>
#include <boost/iostreams/detail/system_failure.hpp>
#include <boost/iostreams/device/mapped_file.hpp>
#ifdef BOOST_IOSTREAMS_WINDOWS
# define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
# include <windows.h>
-# ifndef INVALID_SET_FILE_POINTER
-# define INVALID_SET_FILE_POINTER ((DWORD)-1)
-# endif
#else
# include <errno.h>
# include <fcntl.h>
@@ -38,423 +27,453 @@
# include <unistd.h> // sysconf.
#endif
-#include <boost/iostreams/detail/config/disable_warnings.hpp>
-
namespace boost { namespace iostreams {
namespace detail {
-struct mapped_file_impl {
- mapped_file_impl() { clear(false); }
- ~mapped_file_impl() { try { close(); } catch (...) { } }
- void clear(bool error)
- {
- data_ = 0;
- size_ = 0;
- mode_ = BOOST_IOS::openmode();
- error_ = error;
- #ifdef BOOST_IOSTREAMS_WINDOWS
- handle_ = INVALID_HANDLE_VALUE;
- mapped_handle_ = NULL;
- #else
- handle_ = 0;
- #endif
- #ifndef NDEBUG
- path_.erase();
- #endif
- }
- void close()
- {
- bool error = false;
- #ifdef BOOST_IOSTREAMS_WINDOWS
- if (handle_ == INVALID_HANDLE_VALUE)
- return;
- error = !::UnmapViewOfFile(data_) || error;
- error = !::CloseHandle(mapped_handle_) || error;
- error = !::CloseHandle(handle_) || error;
- handle_ = INVALID_HANDLE_VALUE;
- mapped_handle_ = NULL;
- #else
- if (!handle_)
- return;
- error = ::munmap(reinterpret_cast<char*>(data_), size_) != 0 || error;
- error = ::close(handle_) != 0 || error;
- handle_ = 0;
- #endif
- data_ = 0;
- size_ = 0;
- mode_ = BOOST_IOS::openmode();
- if (error) {
- std::string msg("error closing mapped file");
- #ifndef NDEBUG
- msg += std::string(" (\"") + path_ + "\")";
- #endif
- throw_system_failure(msg);
- }
- #ifndef NDEBUG
- path_.erase();
- #endif
- }
- char* data_;
- std::size_t size_;
- BOOST_IOS::openmode mode_;
- bool error_;
+// Class containing the platform-sepecific implementation
+// Invariant: The members params_, data_, size_, handle_ (and mapped_handle_
+// on Windows) either
+// - all have default values (or INVALID_HANDLE_VALUE for
+// Windows handles), or
+// - all have values reflecting a successful mapping.
+// In the first case, error_ may be true, reflecting a recent unsuccessful
+// open or close attempt; in the second case, error_ is always false.
+class mapped_file_impl {
+public:
+ typedef mapped_file_source::size_type size_type;
+ typedef mapped_file_source::param_type param_type;
+ typedef mapped_file_source::mapmode mapmode;
+ BOOST_STATIC_CONSTANT(
+ size_type, max_length = mapped_file_source::max_length);
+ mapped_file_impl();
+ ~mapped_file_impl();
+ void open(param_type p);
+ bool is_open() const { return data_ != 0; }
+ void close();
+ bool error() const { return error_; }
+ mapmode flags() const { return params_.flags; }
+ std::size_t size() const { return size_; }
+ char* data() const { return data_; }
+ void resize(stream_offset new_size);
+ static int alignment();
+private:
+ void open_file(param_type p);
+ void try_map_file(param_type p);
+ void map_file(param_type& p);
+ bool unmap_file();
+ void clear(bool error);
+ void cleanup_and_throw(const char* msg);
+ param_type params_;
+ char* data_;
+ stream_offset size_;
+ file_handle handle_;
#ifdef BOOST_IOSTREAMS_WINDOWS
- HANDLE handle_;
- HANDLE mapped_handle_;
-#else
- int handle_;
-#endif
-#ifndef NDEBUG
- std::string path_;
+ file_handle mapped_handle_;
#endif
+ bool error_;
};
-} // End namespace detail.
-
-//------------------Definition of mapped_file_source--------------------------//
-
-mapped_file_source::mapped_file_source(mapped_file_params p) { open(p); }
-
-mapped_file_source::mapped_file_source( const std::string& path,
- mapped_file_source::size_type length,
- boost::intmax_t offset )
-{ open(path, length, offset); }
-
-void mapped_file_source::open(mapped_file_params p)
-{
- p.mode &= ~BOOST_IOS::out;
- open_impl(p);
-}
-
-void mapped_file_source::open( const std::string& path,
- mapped_file_source::size_type length,
- boost::intmax_t offset )
-{
- mapped_file_params p(path);
- p.mode = BOOST_IOS::in;
- p.length = length;
- p.offset = offset;
- open_impl(p);
-}
+mapped_file_impl::mapped_file_impl() { clear(false); }
-mapped_file_source::size_type mapped_file_source::size() const
-{ return pimpl_->size_; }
+mapped_file_impl::~mapped_file_impl()
+{ try { close(); } catch (...) { } }
-void mapped_file_source::close() { pimpl_->close(); }
-
-mapped_file_source::operator mapped_file_source::safe_bool() const
+void mapped_file_impl::open(param_type p)
{
- return !!pimpl_ && pimpl_->error_ == false ?
- &safe_bool_helper::x : 0;
+ if (is_open())
+ throw BOOST_IOSTREAMS_FAILURE("file already open");
+ p.normalize();
+ open_file(p);
+ map_file(p); // May modify p.hint
+ params_ = p;
+}
+
+void mapped_file_impl::close()
+{
+ if (data_ == 0)
+ return;
+ bool error = false;
+ error = !unmap_file() || error;
+ error =
+ #ifdef BOOST_IOSTREAMS_WINDOWS
+ !::CloseHandle(handle_)
+ #else
+ ::close(handle_) != 0
+ #endif
+ || error;
+ clear(error);
+ if (error)
+ throw_system_failure("failed closing mapped file");
+}
+
+void mapped_file_impl::resize(stream_offset new_size)
+{
+ if (!is_open())
+ throw BOOST_IOSTREAMS_FAILURE("file is closed");
+ if (flags() & mapped_file::priv)
+ throw BOOST_IOSTREAMS_FAILURE("can't resize private mapped file");
+ if (!(flags() & mapped_file::readwrite))
+ throw BOOST_IOSTREAMS_FAILURE("can't resize readonly mapped file");
+ if (params_.offset >= new_size)
+ throw BOOST_IOSTREAMS_FAILURE("can't resize below mapped offset");
+ if (!unmap_file())
+ cleanup_and_throw("failed unmapping file");
+#ifdef BOOST_IOSTREAMS_WINDOWS
+ stream_offset offset = ::SetFilePointer(handle_, 0, NULL, FILE_CURRENT);
+ if (::GetLastError() != NO_ERROR)
+ cleanup_and_throw("failed querying file pointer");
+ LONG sizehigh = (new_size >> (sizeof(LONG) * 8));
+ LONG sizelow = (new_size & 0xffffffff);
+ ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
+ if (::GetLastError() != NO_ERROR || !::SetEndOfFile(handle_))
+ cleanup_and_throw("failed resizing mapped file");
+ sizehigh = (offset >> (sizeof(LONG) * 8));
+ sizelow = (offset & 0xffffffff);
+ ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
+#else
+ if (BOOST_IOSTREAMS_FD_TRUNCATE(handle_, new_size) == -1)
+ cleanup_and_throw("failed resizing mapped file");
+#endif
+ size_ = new_size;
+ param_type p(params_);
+ map_file(p); // May modify p.hint
+ params_ = p;
}
-bool mapped_file_source::operator!() const
-{ return !!pimpl_ || pimpl_->error_; }
-
-BOOST_IOS::openmode mapped_file_source::mode() const { return pimpl_->mode_; }
-
-const char* mapped_file_source::data() const { return pimpl_->data_; }
-
-const char* mapped_file_source::begin() const { return data(); }
-
-const char* mapped_file_source::end() const { return data() + size(); }
-
-#ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------//
-
-namespace detail {
-
-void cleanup_and_throw(detail::mapped_file_impl& impl, std::string msg)
+int mapped_file_impl::alignment()
{
- #ifndef NDEBUG
- msg += std::string(" (\"") + impl.path_ + "\")";
- #endif
- if (impl.mapped_handle_ != INVALID_HANDLE_VALUE)
- ::CloseHandle(impl.mapped_handle_);
- if (impl.handle_ != NULL)
- ::CloseHandle(impl.handle_);
- impl.clear(true);
- throw_system_failure(msg);
+#ifdef BOOST_IOSTREAMS_WINDOWS
+ SYSTEM_INFO info;
+ ::GetSystemInfo(&info);
+ return static_cast<int>(info.dwAllocationGranularity);
+#else
+ return static_cast<int>(sysconf(_SC_PAGESIZE));
+#endif
}
-} // End namespace detail.
-
-void mapped_file_source::open_impl(mapped_file_params p)
+void mapped_file_impl::open_file(param_type p)
{
- using namespace std;
-
- if (is_open())
- throw BOOST_IOSTREAMS_FAILURE("file already open");
- if (!pimpl_)
- pimpl_.reset(new impl_type);
- else
- pimpl_->clear(false);
- bool readonly = (p.mode & BOOST_IOS::out) == 0;
- pimpl_->mode_ = readonly ? BOOST_IOS::in : (BOOST_IOS::in | BOOST_IOS::out);
- #ifndef NDEBUG
- pimpl_->path_ = detail::absolute_path(p.path);
- #endif
-
- //--------------Open underlying file--------------------------------------//
-
- pimpl_->handle_ =
- ::CreateFileA( p.path.c_str(),
- readonly ? GENERIC_READ : GENERIC_ALL,
- FILE_SHARE_READ,
- NULL,
- (p.new_file_size != 0 && !readonly) ?
- CREATE_ALWAYS :
- OPEN_EXISTING,
- readonly ?
- FILE_ATTRIBUTE_READONLY :
- FILE_ATTRIBUTE_TEMPORARY,
- NULL );
-
- if (pimpl_->handle_ == INVALID_HANDLE_VALUE) {
- detail::cleanup_and_throw(*pimpl_, "failed opening file");
- }
+ bool readonly = p.flags != mapped_file::readwrite;
+#ifdef BOOST_IOSTREAMS_WINDOWS
- //--------------Set file size---------------------------------------------//
+ // Open file
+ DWORD dwDesiredAccess = readonly ? GENERIC_READ : GENERIC_ALL;
+ DWORD dwCreationDisposition = (p.new_file_size != 0 && !readonly) ?
+ CREATE_ALWAYS :
+ OPEN_EXISTING;
+ DWORD dwFlagsandAttributes =
+ readonly ?
+ FILE_ATTRIBUTE_READONLY :
+ FILE_ATTRIBUTE_TEMPORARY;
+ handle_ = p.path.is_wide() ?
+ ::CreateFileW(
+ p.path.c_wstr(),
+ dwDesiredAccess,
+ FILE_SHARE_READ,
+ NULL,
+ dwCreationDisposition,
+ dwFlagsandAttributes,
+ NULL ) :
+ ::CreateFileA(
+ p.path.c_str(),
+ dwDesiredAccess,
+ FILE_SHARE_READ,
+ NULL,
+ dwCreationDisposition,
+ dwFlagsandAttributes,
+ NULL );
+ if (handle_ == INVALID_HANDLE_VALUE)
+ cleanup_and_throw("failed opening file");
+ // Set file size
if (p.new_file_size != 0 && !readonly) {
LONG sizehigh = (p.new_file_size >> (sizeof(LONG) * 8));
LONG sizelow = (p.new_file_size & 0xffffffff);
- DWORD result =
- ::SetFilePointer(pimpl_->handle_, sizelow, &sizehigh, FILE_BEGIN);
- if ( result == INVALID_SET_FILE_POINTER &&
- ::GetLastError() != NO_ERROR ||
- !::SetEndOfFile(pimpl_->handle_) )
- {
- detail::cleanup_and_throw(*pimpl_, "failed setting file size");
- }
- }
-
- //--------------Create mapping--------------------------------------------//
-
- try_again: // Target of goto in following section.
-
- pimpl_->mapped_handle_ =
- ::CreateFileMappingA( pimpl_->handle_, NULL,
- readonly ? PAGE_READONLY : PAGE_READWRITE,
- 0, 0, NULL );
- if (pimpl_->mapped_handle_ == NULL) {
- detail::cleanup_and_throw(*pimpl_, "couldn't create mapping");
+ ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
+ if (::GetLastError() != NO_ERROR || !::SetEndOfFile(handle_))
+ cleanup_and_throw("failed setting file size");
}
- //--------------Access data-----------------------------------------------//
-
- void* data =
- ::MapViewOfFileEx( pimpl_->mapped_handle_,
- readonly ? FILE_MAP_READ : FILE_MAP_WRITE,
- (DWORD) (p.offset >> 32),
- (DWORD) (p.offset & 0xffffffff),
- p.length != max_length ? p.length : 0, (LPVOID) p.hint );
- if (!data) {
- if (p.hint != 0) {
- p.hint = 0;
- goto try_again;
- }
- detail::cleanup_and_throw(*pimpl_, "failed mapping view");
- }
-
- //--------------Determing file size---------------------------------------//
-
- // Dynamically locate GetFileSizeEx (thanks to Pavel Vozenilik).
+ // Determine file size. Dynamically locate GetFileSizeEx for compatibility
+ // with old Platform SDK (thanks to Pavel Vozenilik).
typedef BOOL (WINAPI *func)(HANDLE, PLARGE_INTEGER);
HMODULE hmod = ::GetModuleHandleA("kernel32.dll");
func get_size =
reinterpret_cast<func>(::GetProcAddress(hmod, "GetFileSizeEx"));
-
if (get_size) {
LARGE_INTEGER info;
- if (get_size(pimpl_->handle_, &info)) {
+ if (get_size(handle_, &info)) {
boost::intmax_t size =
( (static_cast<boost::intmax_t>(info.HighPart) << 32) |
info.LowPart );
- pimpl_->size_ =
+ size_ =
static_cast<std::size_t>(
p.length != max_length ?
std::min<boost::intmax_t>(p.length, size) :
size
);
} else {
- detail::cleanup_and_throw(*pimpl_, "failed getting file size");
+ cleanup_and_throw("failed querying file size");
return;
}
} else {
DWORD hi;
DWORD low;
- if ( (low = ::GetFileSize(pimpl_->handle_, &hi))
+ if ( (low = ::GetFileSize(handle_, &hi))
!=
INVALID_FILE_SIZE )
{
boost::intmax_t size =
(static_cast<boost::intmax_t>(hi) << 32) | low;
- pimpl_->size_ =
+ size_ =
static_cast<std::size_t>(
p.length != max_length ?
std::min<boost::intmax_t>(p.length, size) :
size
);
} else {
- detail::cleanup_and_throw(*pimpl_, "failed getting file size");
+ cleanup_and_throw("failed querying file size");
return;
}
}
+#else // #ifdef BOOST_IOSTREAMS_WINDOWS
- pimpl_->data_ = reinterpret_cast<char*>(data);
-}
-
-bool mapped_file_source::is_open() const
-{ return !!pimpl_ && pimpl_->handle_ != INVALID_HANDLE_VALUE; }
-
-int mapped_file_source::alignment()
-{
- SYSTEM_INFO info;
- ::GetSystemInfo(&info);
- return static_cast<int>(info.dwAllocationGranularity);
-}
-
-#else // #ifdef BOOST_IOSTREAMS_WINDOWS //------------------------------------//
-
-namespace detail {
-
- void cleanup_and_throw(detail::mapped_file_impl& impl, std::string msg)
-{
- #ifndef NDEBUG
- msg += std::string(" (\"") + impl.path_ + "\")";
- #endif
- if (impl.handle_ != 0)
- ::close(impl.handle_);
- impl.clear(true);
- throw_system_failure(msg);
-}
-
-} // End namespace detail.
-
-
-void mapped_file_source::open_impl(mapped_file_params p)
-{
- using namespace std;
-
- if (is_open())
- throw BOOST_IOSTREAMS_FAILURE("file already open");
- if (!pimpl_)
- pimpl_.reset(new impl_type);
- else
- pimpl_->clear(false);
- bool readonly = (p.mode & BOOST_IOS::out) == 0;
- pimpl_->mode_ = readonly ? BOOST_IOS::in : (BOOST_IOS::in | BOOST_IOS::out);
- #ifndef NDEBUG
- pimpl_->path_ = detail::absolute_path(p.path);
- #endif
-
- //--------------Open underlying file--------------------------------------//
-
+ // Open file
int flags = (readonly ? O_RDONLY : O_RDWR);
if (p.new_file_size != 0 && !readonly)
flags |= (O_CREAT | O_TRUNC);
+ #ifdef _LARGEFILE64_SOURCE
+ flags |= O_LARGEFILE;
+ #endif
errno = 0;
- pimpl_->handle_ = ::open(p.path.c_str(), flags, S_IRWXU);
+ handle_ = ::open(p.path.c_str(), flags, S_IRWXU);
if (errno != 0)
- detail::cleanup_and_throw(*pimpl_, "failed opening file");
+ cleanup_and_throw("failed opening file");
//--------------Set file size---------------------------------------------//
if (p.new_file_size != 0 && !readonly)
- if (ftruncate(pimpl_->handle_, p.new_file_size) == -1)
- detail::cleanup_and_throw(*pimpl_, "failed setting file size");
+ if (BOOST_IOSTREAMS_FD_TRUNCATE(handle_, p.new_file_size) == -1)
+ cleanup_and_throw("failed setting file size");
//--------------Determine file size---------------------------------------//
bool success = true;
- struct stat info;
- if (p.length != max_length)
- pimpl_->size_ = p.length;
- else {
- success = ::fstat(pimpl_->handle_, &info) != -1;
- pimpl_->size_ = info.st_size;
+ if (p.length != max_length) {
+ size_ = p.length;
+ } else {
+ struct BOOST_IOSTREAMS_FD_STAT info;
+ success = ::BOOST_IOSTREAMS_FD_FSTAT(handle_, &info) != -1;
+ size_ = info.st_size;
}
if (!success)
- detail::cleanup_and_throw(*pimpl_, "failed getting file size");
+ cleanup_and_throw("failed querying file size");
+#endif // #ifdef BOOST_IOSTREAMS_WINDOWS
+}
- //--------------Create mapping--------------------------------------------//
+void mapped_file_impl::try_map_file(param_type p)
+{
+ bool priv = p.flags == mapped_file::priv;
+ bool readonly = p.flags == mapped_file::readonly;
+#ifdef BOOST_IOSTREAMS_WINDOWS
- try_again: // Target of goto in following section.
+ // Create mapping
+ DWORD protect = priv ?
+ PAGE_WRITECOPY :
+ readonly ?
+ PAGE_READONLY :
+ PAGE_READWRITE;
+ mapped_handle_ =
+ ::CreateFileMappingA(
+ handle_,
+ NULL,
+ protect,
+ 0,
+ 0,
+ NULL );
+ if (mapped_handle_ == NULL)
+ cleanup_and_throw("failed create mapping");
+
+ // Access data
+ DWORD access = priv ?
+ FILE_MAP_COPY :
+ readonly ?
+ FILE_MAP_READ :
+ FILE_MAP_WRITE;
+ void* data =
+ ::MapViewOfFileEx(
+ mapped_handle_,
+ access,
+ (DWORD) (p.offset >> 32),
+ (DWORD) (p.offset & 0xffffffff),
+ size_ != max_length ? size_ : 0,
+ (LPVOID) p.hint );
+ if (!data)
+ cleanup_and_throw("failed mapping view");
+#else
+ void* data =
+ ::BOOST_IOSTREAMS_FD_MMAP(
+ const_cast<char*>(p.hint),
+ size_,
+ readonly ? PROT_READ : (PROT_READ | PROT_WRITE),
+ priv ? MAP_PRIVATE : MAP_SHARED,
+ handle_,
+ p.offset );
+ if (data == MAP_FAILED)
+ cleanup_and_throw("failed mapping file");
+#endif
+ data_ = static_cast<char*>(data);
+}
- char* hint = const_cast<char*>(p.hint);
- void* data = ::mmap( hint, pimpl_->size_,
- readonly ? PROT_READ : (PROT_READ | PROT_WRITE),
- readonly ? MAP_PRIVATE : MAP_SHARED,
- pimpl_->handle_, p.offset );
- if (data == MAP_FAILED) {
- if (hint != 0) {
- hint = 0;
- goto try_again;
+void mapped_file_impl::map_file(param_type& p)
+{
+ try {
+ try_map_file(p);
+ } catch (const std::exception& e) {
+ if (p.hint) {
+ p.hint = 0;
+ try_map_file(p);
+ } else {
+ throw e;
}
- detail::cleanup_and_throw(*pimpl_, "failed mapping file");
}
- pimpl_->data_ = reinterpret_cast<char*>(data);
+}
- return;
+bool mapped_file_impl::unmap_file()
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+ bool error = false;
+ error = !::UnmapViewOfFile(data_) || error;
+ error = !::CloseHandle(mapped_handle_) || error;
+ mapped_handle_ = NULL;
+ return !error;
+#else
+ return ::munmap(data_, size_) == 0;
+#endif
}
+void mapped_file_impl::clear(bool error)
+{
+ params_ = param_type();
+ data_ = 0;
+ size_ = 0;
+#ifdef BOOST_IOSTREAMS_WINDOWS
+ handle_ = INVALID_HANDLE_VALUE;
+ mapped_handle_ = NULL;
+#else
+ handle_ = 0;
+#endif
+ error_ = error;
+}
+
+// Called when an error is encountered during the execution of open_file or
+// map_file
+void mapped_file_impl::cleanup_and_throw(const char* msg)
+{
+#ifdef BOOST_IOSTREAMS_WINDOWS
+ DWORD error = GetLastError();
+ if (mapped_handle_ != INVALID_HANDLE_VALUE)
+ ::CloseHandle(mapped_handle_);
+ if (handle_ != NULL)
+ ::CloseHandle(handle_);
+ SetLastError(error);
+#else
+ int error = errno;
+ if (handle_ != 0)
+ ::close(handle_);
+ errno = error;
+#endif
+ clear(true);
+ boost::iostreams::detail::throw_system_failure(msg);
+}
+
+//------------------Implementation of mapped_file_params_base-----------------//
+
+void mapped_file_params_base::normalize()
+{
+ if (mode && flags)
+ throw BOOST_IOSTREAMS_FAILURE(
+ "at most one of 'mode' and 'flags' may be specified"
+ );
+ if (flags) {
+ switch (flags) {
+ case mapped_file::readonly:
+ case mapped_file::readwrite:
+ case mapped_file::priv:
+ break;
+ default:
+ throw BOOST_IOSTREAMS_FAILURE("invalid flags");
+ }
+ } else {
+ flags = (mode & BOOST_IOS::out) ?
+ mapped_file::readwrite :
+ mapped_file::readonly;
+ mode = BOOST_IOS::openmode();
+ }
+ if (offset < 0)
+ throw BOOST_IOSTREAMS_FAILURE("invalid offset");
+ if (new_file_size < 0)
+ throw BOOST_IOSTREAMS_FAILURE("invalid new file size");
+}
+
+} // End namespace detail.
+
+//------------------Implementation of mapped_file_source----------------------//
+
+mapped_file_source::mapped_file_source()
+ : pimpl_(new impl_type)
+ { }
+
+mapped_file_source::mapped_file_source(const mapped_file_source& other)
+ : pimpl_(other.pimpl_)
+ { }
+
bool mapped_file_source::is_open() const
-{ return !!pimpl_ && pimpl_->handle_ != 0; }
+{ return pimpl_->is_open(); }
-int mapped_file_source::alignment()
-{ return static_cast<int>(sysconf(_SC_PAGESIZE)); }
+void mapped_file_source::close() { pimpl_->close(); }
-#endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------//
+mapped_file_source::operator safe_bool() const
+{ return pimpl_->error() ? &safe_bool_helper::x : 0; }
-//------------------Implementation of mapped_file-----------------------------//
+bool mapped_file_source::operator!() const
+{ return pimpl_->error(); }
-mapped_file::mapped_file(mapped_file_params p) { delegate_.open_impl(p); }
+mapped_file_source::mapmode mapped_file_source::flags() const
+{ return pimpl_->flags(); }
-mapped_file::mapped_file( const std::string& path, BOOST_IOS::openmode mode,
- size_type length, stream_offset offset )
-{ open(path, mode, length, offset); }
-
-void mapped_file::open(mapped_file_params p)
-{ delegate_.open_impl(p); }
-
-void mapped_file::open( const std::string& path, BOOST_IOS::openmode mode,
- size_type length, stream_offset offset )
-{
- mapped_file_params p(path);
- p.mode = mode;
- p.length = length;
- p.offset = offset;
- open(p);
-}
+mapped_file_source::size_type mapped_file_source::size() const
+{ return pimpl_->size(); }
-//------------------Implementation of mapped_file_sink------------------------//
+const char* mapped_file_source::data() const { return pimpl_->data(); }
-mapped_file_sink::mapped_file_sink(mapped_file_params p) { open(p); }
+const char* mapped_file_source::begin() const { return data(); }
-mapped_file_sink::mapped_file_sink( const std::string& path,
- size_type length, stream_offset offset )
-{ open(path, length, offset); }
+const char* mapped_file_source::end() const { return data() + size(); }
+int mapped_file_source::alignment()
+{ return detail::mapped_file_impl::alignment(); }
-void mapped_file_sink::open(mapped_file_params p)
-{
- p.mode |= BOOST_IOS::out;
- p.mode &= ~BOOST_IOS::in;
- mapped_file::open(p);
-}
+void mapped_file_source::init() { pimpl_.reset(new impl_type); }
-void mapped_file_sink::open( const std::string& path, size_type length,
- stream_offset offset )
-{
- mapped_file_params p(path);
- p.mode = BOOST_IOS::out;
- p.length = length;
- p.offset = offset;
- open(p);
-}
+void mapped_file_source::open_impl(const param_type& p)
+{ pimpl_->open(p); }
+
+//------------------Implementation of mapped_file-----------------------------//
+
+mapped_file::mapped_file(const mapped_file& other)
+ : delegate_(other.delegate_)
+ { }
+
+void mapped_file::resize(stream_offset new_size)
+{ delegate_.pimpl_->resize(new_size); }
+
+//------------------Implementation of mapped_file_sink------------------------//
+
+mapped_file_sink::mapped_file_sink(const mapped_file_sink& other)
+ : mapped_file(static_cast<const mapped_file&>(other))
+ { }
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
-
-#include <boost/iostreams/detail/config/enable_warnings.hpp>
Modified: branches/release/libs/iostreams/test/large_file_test.cpp
==============================================================================
--- branches/release/libs/iostreams/test/large_file_test.cpp (original)
+++ branches/release/libs/iostreams/test/large_file_test.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -292,7 +292,7 @@
// Close file
CloseHandle(hnd);
- return true;
+ return true;
# endif // Borland workaround
#else // #ifdef BOOST_IOSTREAMS_WINDOWS
@@ -343,7 +343,7 @@
// Close file
BOOST_IOSTREAMS_FD_CLOSE(fd);
- return true;
+ return true;
# else // Cygwin
Modified: branches/release/libs/iostreams/test/mapped_file_test.cpp
==============================================================================
--- branches/release/libs/iostreams/test/mapped_file_test.cpp (original)
+++ branches/release/libs/iostreams/test/mapped_file_test.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -1,33 +1,70 @@
-// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
-// (C) Copyright 2004-2007 Jonathan Turkanis
+// (C) Copyright Jorge Lodos 2008
+// (C) Copyright Jonathan Turkanis 2004
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
// See http://www.boost.org/libs/iostreams for documentation.
+// This is the original (boost 1.34) boost::iostream test for the mapped files with the
+// following modifications:
+// 1. The namespace for the mapped file was changed to seglib::filemap.
+// 2. Added test for privately mapped files.
+// 3. The test test_writeable was added for mapped files.
+// 4. The test test_resizeable was added for mapped files.
+//
+
#include <fstream>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#include <boost/iostreams/device/mapped_file.hpp>
-#include <boost/iostreams/stream.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
+
+#include <boost/iostreams/stream.hpp>
+#include <boost/iostreams/device/mapped_file.hpp>
#include "detail/temp_file.hpp"
#include "detail/verification.hpp"
-using namespace std;
-using namespace boost;
-using namespace boost::iostreams;
-using namespace boost::iostreams::test;
-using boost::unit_test::test_suite;
-
// Code generation bugs cause tests to fail with global optimization.
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# pragma optimize("g", off)
#endif
+namespace boost { namespace iostreams { namespace test {
+
+bool test_writeable(mapped_file& mf)
+{
+ // Test writing
+ for (int i = 0; i < data_reps; ++i) {
+ memcpy(mf.data(), narrow_data(), chunk_size);
+ char buf[chunk_size];
+ memcpy(buf, mf.const_data(), chunk_size);
+ if (strncmp(buf, narrow_data(), chunk_size) != 0)
+ return false;
+ memset(mf.data(), 0, chunk_size);
+ }
+ return true;
+}
+
+bool test_resizeable(mapped_file& mf)
+{
+ // Test resizing
+ mapped_file::size_type size = mf.size();
+ if (size == 0)
+ return false;
+ mf.resize(size/2);
+ if (mf.size() != size/2)
+ return false;
+ mf.resize(size);
+ if (mf.size() != size)
+ return false;
+ return true;
+}
+
+} } } // End namespaces test, iostreams, boost.
+
void mapped_file_test()
{
+ using namespace boost::iostreams;
BOOST_MESSAGE("about to begin");
//--------------Reading from a mapped_file_source-------------------------//
@@ -38,13 +75,13 @@
// Test reading from a stream based on a mapped_file_source,
// in chars.
- test_file test1, test2;
- stream<mapped_file_source> first(test1.name());
+ boost::iostreams::test::test_file test1, test2;
+ boost::iostreams::stream<mapped_file_source> first(test1.name());
{
- ifstream second( test2.name().c_str(),
+ std::ifstream second( test2.name().c_str(),
BOOST_IOS::in | BOOST_IOS::binary );
BOOST_CHECK_MESSAGE(
- compare_streams_in_chars(first, second),
+ boost::iostreams::test::compare_streams_in_chars(first, second),
"failed reading from stream<mapped_file_source> in chars"
);
@@ -58,10 +95,10 @@
// in chunks. (Also tests reopening the stream.)
first.open(mapped_file_source(test1.name()));
{
- ifstream second( test2.name().c_str(),
+ std::ifstream second( test2.name().c_str(),
BOOST_IOS::in | BOOST_IOS::binary );
BOOST_CHECK_MESSAGE(
- compare_streams_in_chunks(first, second),
+ boost::iostreams::test::compare_streams_in_chunks(first, second),
"failed reading from stream<mapped_file_source> in chunks"
);
@@ -76,15 +113,15 @@
{
// Test writing to a stream based on a mapped_file_sink, in
// chars.
- uppercase_file first, second; // Will overwrite these.
- test_file test;
+ boost::iostreams::test::uppercase_file first, second; // Will overwrite these.
+ boost::iostreams::test::test_file test;
- stream<mapped_file_sink> out;
+ boost::iostreams::stream<mapped_file_sink> out;
out.open(mapped_file_sink(first.name()));
- write_data_in_chars(out);
+ boost::iostreams::test::write_data_in_chars(out);
out.close();
BOOST_CHECK_MESSAGE(
- compare_files(first.name(), test.name()),
+ boost::iostreams::test::compare_files(first.name(), test.name()),
"failed writing to stream<mapped_file_sink> in chars"
);
@@ -95,10 +132,10 @@
// Test writing to a stream based on a mapped_file_sink, in
// chunks. (Also tests reopening the stream.)
out.open(mapped_file_sink(second.name()));
- write_data_in_chunks(out);
+ boost::iostreams::test::write_data_in_chunks(out);
out.close();
BOOST_CHECK_MESSAGE(
- compare_files(second.name(), test.name()),
+ boost::iostreams::test::compare_files(second.name(), test.name()),
"failed writing to stream<mapped_file_sink> in chunks"
);
@@ -107,21 +144,21 @@
);
}
- //--------------Writing to a newly created file-----------------------------//
+ //--------------Writing to a newly created file---------------------------//
{
// Test writing to a newly created mapped file.
- temp_file first, second;
- test_file test;
+ boost::iostreams::test::temp_file first, second;
+ boost::iostreams::test::test_file test;
mapped_file_params p(first.name());
- p.new_file_size = data_reps * data_length();
- stream<mapped_file_sink> out;
+ p.new_file_size = boost::iostreams::test::data_reps * boost::iostreams::test::data_length();
+ boost::iostreams::stream<mapped_file_sink> out;
out.open(mapped_file_sink(p));
- write_data_in_chars(out);
+ boost::iostreams::test::write_data_in_chars(out);
out.close();
BOOST_CHECK_MESSAGE(
- compare_files(first.name(), test.name()),
+ boost::iostreams::test::compare_files(first.name(), test.name()),
"failed writing to newly created mapped file in chars"
);
@@ -130,10 +167,10 @@
// (Also tests reopening the stream.)
p.path = second.name();
out.open(mapped_file_sink(p));
- write_data_in_chunks(out);
+ boost::iostreams::test::write_data_in_chunks(out);
out.close();
BOOST_CHECK_MESSAGE(
- compare_files(second.name(), test.name()),
+ boost::iostreams::test::compare_files(second.name(), test.name()),
"failed writing to newly created mapped file in chunks"
);
}
@@ -143,11 +180,11 @@
{
// Test reading, writing and seeking within a stream based on a
// mapped_file, in chars.
- test_file test;
- stream<mapped_file> io;
+ boost::iostreams::test::test_file test;
+ boost::iostreams::stream<mapped_file> io;
io.open(mapped_file(test.name()));
BOOST_CHECK_MESSAGE(
- test_seekable_in_chars(io),
+ boost::iostreams::test::test_seekable_in_chars(io),
"failed seeking within stream<mapped_file> in chars"
);
@@ -162,7 +199,7 @@
// stream.)
io.open(mapped_file(test.name()));
BOOST_CHECK_MESSAGE(
- test_seekable_in_chunks(io),
+ boost::iostreams::test::test_seekable_in_chunks(io),
"failed seeking within stream<mapped_file> in chunks"
);
@@ -170,15 +207,74 @@
"done seeking within stream<mapped_file> in chunks"
);
}
+
+ //--------------Resizing a mapped_file------------------------------------//
+
+ {
+ // Test resizing a mapped_file.
+ boost::iostreams::test::test_file test;
+ mapped_file mf;
+ mf.open(test.name());
+ BOOST_CHECK_MESSAGE(
+ boost::iostreams::test::test_resizeable(mf),
+ "failed resizing a mapped_file"
+ );
+
+ BOOST_MESSAGE(
+ "done resizing a mapped_file"
+ );
+ }
+
+ //--------------Random access with a private mapped_file------------------//
+
+ {
+ // Use 2 copies of the file to compare later
+ boost::iostreams::test::test_file orig, copy;
+
+ // Test reading and writing within a mapped_file.
+ // Since the file is privately mapped, it should remain
+ // unchanged after writing when opened in readonly mode.
+ mapped_file mf;
+ mf.open(orig.name(), mapped_file::priv);
+ BOOST_CHECK_MESSAGE(
+ boost::iostreams::test::test_writeable(mf),
+ "failed seeking within private mapped_file"
+ );
+ BOOST_CHECK_MESSAGE(
+ boost::iostreams::test::compare_files(orig.name(), copy.name()),
+ "failed writing to private mapped_file"
+ );
+
+ BOOST_MESSAGE(
+ "done seeking within private mapped_file"
+ );
+
+ mf.close();
+
+ // Test reopening the mapped file.
+ mf.open(orig.name(), mapped_file::priv);
+ BOOST_CHECK_MESSAGE(
+ boost::iostreams::test::test_writeable(mf),
+ "failed reopening private mapped_file"
+ );
+ BOOST_CHECK_MESSAGE(
+ boost::iostreams::test::compare_files(orig.name(), copy.name()),
+ "failed writing to reopened private mapped_file"
+ );
+
+ BOOST_MESSAGE(
+ "done reopening private mapped_file"
+ );
+ }
}
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# pragma optimize("", on)
#endif
-test_suite* init_unit_test_suite(int, char* [])
+boost::unit_test::test_suite* init_unit_test_suite(int, char* [])
{
- test_suite* test = BOOST_TEST_SUITE("mapped_file test");
+ boost::unit_test::test_suite* test = BOOST_TEST_SUITE("mapped_file test");
test->add(BOOST_TEST_CASE(&mapped_file_test));
return test;
}
Modified: branches/release/libs/numeric/ublas/test/triangular_layout.cpp
==============================================================================
--- branches/release/libs/numeric/ublas/test/triangular_layout.cpp (original)
+++ branches/release/libs/numeric/ublas/test/triangular_layout.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -14,126 +14,126 @@
int main(int argc, char* argv[])
{
- int sz = 4;
- ublas::symmetric_matrix<int, ublas::upper, ublas::column_major> UpCol (sz, sz);
- ublas::symmetric_matrix<int, ublas::upper, ublas::row_major> UpRow (sz, sz);
- ublas::symmetric_matrix<int, ublas::lower, ublas::column_major> LoCol (sz, sz);
- ublas::symmetric_matrix<int, ublas::lower, ublas::row_major> LoRow (sz, sz);
-
- ublas::triangular_matrix<int, ublas::upper, ublas::column_major> TrUpCol (sz, sz);
- ublas::triangular_matrix<int, ublas::upper, ublas::row_major> TrUpRow (sz, sz);
- ublas::triangular_matrix<int, ublas::lower, ublas::column_major> TrLoCol (sz, sz);
- ublas::triangular_matrix<int, ublas::lower, ublas::row_major> TrLoRow (sz, sz);
-
- for(int i=0; i<sz; ++i)
- for(int j=i; j<sz; ++j)
- {
- // Symmetric
- UpCol(i,j) = 10*i + j;
- UpRow(i,j) = 10*i + j;
- LoCol(i,j) = 10*i + j;
- LoRow(i,j) = 10*i + j;
- // Triangular
- TrUpCol(i,j) = 10*i + j;
- TrUpRow(i,j) = 10*i + j;
- TrLoCol(j,i) = 10*i + j;
- TrLoRow(j,i) = 10*i + j;
- }
-
- //get pointers to data
- int* uc = &(UpCol.data()[0]);
- int* ur = &(UpRow.data()[0]);
- int* lc = &(LoCol.data()[0]);
- int* lr = &(LoRow.data()[0]);
- int* tuc = &(TrUpCol.data()[0]);
- int* tur = &(TrUpRow.data()[0]);
- int* tlc = &(TrLoCol.data()[0]);
- int* tlr = &(TrLoRow.data()[0]);
-
- // upper, column_major
- // storage should be: 0 1 11 2 12 22 3 13 23 33
- int uc_correct[] = {0, 1, 11, 2, 12, 22, 3, 13, 23, 33};
-
- // upper, row_major
- // storage should be: 0 1 2 3 11 12 13 22 23 33
- int ur_correct[] = {0, 1, 2, 3, 11, 12, 13, 22, 23, 33};
-
- // lower, column_major
- // storage should be: 0 1 2 3 11 12 13 22 23 33
- int lc_correct[] = {0, 1, 2, 3, 11, 12, 13, 22, 23, 33};
-
- // lower, row_major
- // storage should be: 0 1 11 2 12 22 3 13 23 33
- int lr_correct[] = {0, 1, 11, 2, 12, 22, 3, 13, 23, 33};
+ int sz = 4;
+ ublas::symmetric_matrix<int, ublas::upper, ublas::column_major> UpCol (sz, sz);
+ ublas::symmetric_matrix<int, ublas::upper, ublas::row_major> UpRow (sz, sz);
+ ublas::symmetric_matrix<int, ublas::lower, ublas::column_major> LoCol (sz, sz);
+ ublas::symmetric_matrix<int, ublas::lower, ublas::row_major> LoRow (sz, sz);
+
+ ublas::triangular_matrix<int, ublas::upper, ublas::column_major> TrUpCol (sz, sz);
+ ublas::triangular_matrix<int, ublas::upper, ublas::row_major> TrUpRow (sz, sz);
+ ublas::triangular_matrix<int, ublas::lower, ublas::column_major> TrLoCol (sz, sz);
+ ublas::triangular_matrix<int, ublas::lower, ublas::row_major> TrLoRow (sz, sz);
+
+ for(int i=0; i<sz; ++i)
+ for(int j=i; j<sz; ++j)
+ {
+ // Symmetric
+ UpCol(i,j) = 10*i + j;
+ UpRow(i,j) = 10*i + j;
+ LoCol(i,j) = 10*i + j;
+ LoRow(i,j) = 10*i + j;
+ // Triangular
+ TrUpCol(i,j) = 10*i + j;
+ TrUpRow(i,j) = 10*i + j;
+ TrLoCol(j,i) = 10*i + j;
+ TrLoRow(j,i) = 10*i + j;
+ }
+
+ //get pointers to data
+ int* uc = &(UpCol.data()[0]);
+ int* ur = &(UpRow.data()[0]);
+ int* lc = &(LoCol.data()[0]);
+ int* lr = &(LoRow.data()[0]);
+ int* tuc = &(TrUpCol.data()[0]);
+ int* tur = &(TrUpRow.data()[0]);
+ int* tlc = &(TrLoCol.data()[0]);
+ int* tlr = &(TrLoRow.data()[0]);
+
+ // upper, column_major
+ // storage should be: 0 1 11 2 12 22 3 13 23 33
+ int uc_correct[] = {0, 1, 11, 2, 12, 22, 3, 13, 23, 33};
+
+ // upper, row_major
+ // storage should be: 0 1 2 3 11 12 13 22 23 33
+ int ur_correct[] = {0, 1, 2, 3, 11, 12, 13, 22, 23, 33};
+
+ // lower, column_major
+ // storage should be: 0 1 2 3 11 12 13 22 23 33
+ int lc_correct[] = {0, 1, 2, 3, 11, 12, 13, 22, 23, 33};
+
+ // lower, row_major
+ // storage should be: 0 1 11 2 12 22 3 13 23 33
+ int lr_correct[] = {0, 1, 11, 2, 12, 22, 3, 13, 23, 33};
bool success = true;
- // Test Symmetric
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(uc[i] != uc_correct[i])
- {
- cout << "Storage error (Symmetric, Upper, Column major)" << endl;
- success = false;
- break;
- }
-
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(ur[i] != ur_correct[i])
- {
- cout << "Storage error (Symmetric, Upper, Row major)" << endl;
- success = false;
- break;
- }
-
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(lc[i] != lc_correct[i])
- {
- cout << "Storage error (Symmetric, Lower, Column major)" << endl;
- success = false;
- break;
- }
-
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(lr[i] != lr_correct[i])
- {
- cout << "Storage error (Symmetric, Lower, Row major)" << endl;
- success = false;
- break;
- }
-
- // Test Triangular
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(tuc[i] != uc_correct[i])
- {
- cout << "Storage error (Triangular, Upper, Column major)" << endl;
- success = false;
- break;
- }
-
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(tur[i] != ur_correct[i])
- {
- cout << "Storage error (Triangular, Upper, Row major)" << endl;
- success = false;
- break;
- }
-
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(tlc[i] != lc_correct[i])
- {
- cout << "Storage error (Triangular, Lower, Column major)" << endl;
- success = false;
- break;
- }
-
- for(int i=0; i<sz*(sz+1)/2; ++i)
- if(tlr[i] != lr_correct[i])
- {
- cout << "Storage error (Triangular, Lower, Row major)" << endl;
+ // Test Symmetric
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(uc[i] != uc_correct[i])
+ {
+ cout << "Storage error (Symmetric, Upper, Column major)" << endl;
+ success = false;
+ break;
+ }
+
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(ur[i] != ur_correct[i])
+ {
+ cout << "Storage error (Symmetric, Upper, Row major)" << endl;
+ success = false;
+ break;
+ }
+
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(lc[i] != lc_correct[i])
+ {
+ cout << "Storage error (Symmetric, Lower, Column major)" << endl;
+ success = false;
+ break;
+ }
+
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(lr[i] != lr_correct[i])
+ {
+ cout << "Storage error (Symmetric, Lower, Row major)" << endl;
+ success = false;
+ break;
+ }
+
+ // Test Triangular
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(tuc[i] != uc_correct[i])
+ {
+ cout << "Storage error (Triangular, Upper, Column major)" << endl;
+ success = false;
+ break;
+ }
+
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(tur[i] != ur_correct[i])
+ {
+ cout << "Storage error (Triangular, Upper, Row major)" << endl;
+ success = false;
+ break;
+ }
+
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(tlc[i] != lc_correct[i])
+ {
+ cout << "Storage error (Triangular, Lower, Column major)" << endl;
+ success = false;
+ break;
+ }
+
+ for(int i=0; i<sz*(sz+1)/2; ++i)
+ if(tlr[i] != lr_correct[i])
+ {
+ cout << "Storage error (Triangular, Lower, Row major)" << endl;
success = false;
- break;
- }
+ break;
+ }
-
- return (success)?boost::exit_success:boost::exit_failure;
+
+ return (success)?boost::exit_success:boost::exit_failure;
}
Modified: branches/release/libs/optional/test/optional_test_ref.cpp
==============================================================================
--- branches/release/libs/optional/test/optional_test_ref.cpp (original)
+++ branches/release/libs/optional/test/optional_test_ref.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -342,14 +342,14 @@
int i = 0 ;
optional<int&> ori1 = i ;
BOOST_CHECK( &(*ori1) == &i ) ;
-
+
optional<int&> ori2(i) ;
BOOST_CHECK( &(*ori2) == &i ) ;
-
+
int const ci = 0 ;
optional<int const&> orci1 = ci ;
BOOST_CHECK( &(*orci1) == &ci ) ;
-
+
optional<int const&> orci2(ci) ;
BOOST_CHECK( &(*orci2) == &ci ) ;
}
@@ -360,7 +360,7 @@
{
test_with_class_type();
test_with_builtin_types();
- test_binding();
+ test_binding();
}
catch ( ... )
{
Modified: branches/release/libs/python/test/map_indexing_suite.cpp
==============================================================================
--- branches/release/libs/python/test/map_indexing_suite.cpp (original)
+++ branches/release/libs/python/test/map_indexing_suite.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -62,7 +62,7 @@
void a_map_indexing_suite(); // moved to a_map_indexing_suite.cpp to
a_map_indexing_suite(); // avoid MSVC 6/7 internal structure overflow
-
+
}
#include "module_tail.cpp"
Modified: branches/release/libs/rational/test/rational_test.cpp
==============================================================================
--- branches/release/libs/rational/test/rational_test.cpp (original)
+++ branches/release/libs/rational/test/rational_test.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -26,6 +26,7 @@
#define BOOST_TEST_MAIN "Boost::Rational unit tests"
+#include <boost/config.hpp>
#include <boost/mpl/list.hpp>
#include <boost/operators.hpp>
#include <boost/preprocessor/stringize.hpp>
@@ -227,8 +228,8 @@
public:
static const bool is_specialized = limits_type::is_specialized;
- static MyInt min() throw() { return limits_type::min(); }
- static MyInt max() throw() { return limits_type::max(); }
+ static MyInt min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return (limits_type::min)(); }
+ static MyInt max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return (limits_type::max)(); }
static const int digits = limits_type::digits;
static const int digits10 = limits_type::digits10;
@@ -273,8 +274,8 @@
public:
static const bool is_specialized = limits_type::is_specialized;
- static MyOverflowingUnsigned min() throw() { return limits_type::min(); }
- static MyOverflowingUnsigned max() throw() { return limits_type::max(); }
+ static MyOverflowingUnsigned min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return (limits_type::min)(); }
+ static MyOverflowingUnsigned max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return (limits_type::max)(); }
static const int digits = limits_type::digits;
static const int digits10 = limits_type::digits10;
Modified: branches/release/libs/serialization/example/portable_binary_iarchive.hpp
==============================================================================
--- branches/release/libs/serialization/example/portable_binary_iarchive.hpp (original)
+++ branches/release/libs/serialization/example/portable_binary_iarchive.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -69,9 +69,9 @@
public boost::archive::detail::common_iarchive<
portable_binary_iarchive
>
- ,
+ ,
public boost::archive::detail::shared_ptr_helper
- {
+ {
typedef boost::archive::basic_binary_iprimitive<
portable_binary_iarchive,
std::istream::char_type,
Modified: branches/release/libs/serialization/src/extended_type_info_typeid.cpp
==============================================================================
--- branches/release/libs/serialization/src/extended_type_info_typeid.cpp (original)
+++ branches/release/libs/serialization/src/extended_type_info_typeid.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -92,8 +92,8 @@
// remove entry in map which corresponds to this type
do{
if(this == *start)
- x.erase(start++);
- else
+ x.erase(start++);
+ else
++start;
}while(start != end);
}
Modified: branches/release/libs/spirit/classic/example/intermediate/simple_xml/tag.hpp
==============================================================================
--- branches/release/libs/spirit/classic/example/intermediate/simple_xml/tag.hpp (original)
+++ branches/release/libs/spirit/classic/example/intermediate/simple_xml/tag.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -12,14 +12,14 @@
struct tag
{
- std::string id;
+ std::string id;
std::map<std::string,std::string> attributes;
typedef boost::variant<
std::string,
boost::recursive_wrapper<tag>
>
variant_type;
- std::list<variant_type> children;
+ std::list<variant_type> children;
};
Modified: branches/release/libs/utility/swap/test/std_bitset.cpp
==============================================================================
--- branches/release/libs/utility/swap/test/std_bitset.cpp (original)
+++ branches/release/libs/utility/swap/test/std_bitset.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -19,7 +19,7 @@
typedef std::bitset<8> bitset_type;
const bitset_type initial_value1 = 1ul;
const bitset_type initial_value2 = 2ul;
-
+
bitset_type object1 = initial_value1;
bitset_type object2 = initial_value2;
Modified: branches/release/libs/utility/swap/test/swap_test_class.hpp
==============================================================================
--- branches/release/libs/utility/swap/test/swap_test_class.hpp (original)
+++ branches/release/libs/utility/swap/test/swap_test_class.hpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -12,7 +12,7 @@
class swap_test_class
{
- int m_data;
+ int m_data;
public:
explicit swap_test_class(int arg = 0)
:
Modified: branches/release/tools/regression/src/library_status.cpp
==============================================================================
--- branches/release/tools/regression/src/library_status.cpp (original)
+++ branches/release/tools/regression/src/library_status.cpp 2009-05-20 15:41:20 EDT (Wed, 20 May 2009)
@@ -111,7 +111,7 @@
for(itr = m_subcolumns.begin(); itr != m_subcolumns.end(); ++itr){
std::pair<int, int> spans;
spans = itr->second.get_spans();
- rows = std::max(rows, spans.first);
+ rows = (std::max)(rows, spans.first);
cols += spans.second;
}
++rows;
@@ -661,7 +661,7 @@
col_node::subcolumns_t::const_iterator itr;
int max_depth = 1;
for(itr = root.m_subcolumns.begin(); itr != root.m_subcolumns.end(); ++itr){
- max_depth = std::max(max_depth, itr->second.rows);
+ max_depth = (std::max)(max_depth, itr->second.rows);
}
return max_depth;
}
@@ -856,9 +856,9 @@
" options: --compiler name Run for named compiler only\n"
" --ignore-pass Do not report tests which pass all compilers\n"
" --no-warn Warnings not reported if test passes\n"
- " --boost-root path default derived from current path.\n"
- " --locate-root path Path to ALL_LOCATE_TARGET for bjam;\n"
- " default boost-root.\n"
+ " --boost-root path default derived from current path.\n"
+ " --locate-root path Path to ALL_LOCATE_TARGET for bjam;\n"
+ " default boost-root.\n"
" --comment path Path to file containing HTML\n"
" to be copied into status-file.\n"
" --notes path Path to file containing HTML\n"
@@ -873,10 +873,10 @@
return 1;
}
- if(boost_root.empty())
- boost_root = find_boost_root();
- if ( locate_root.empty() )
- locate_root = boost_root;
+ if(boost_root.empty())
+ boost_root = find_boost_root();
+ if ( locate_root.empty() )
+ locate_root = boost_root;
report.open( fs::path( argv[1], fs::native ) );
if ( !report )