Update of /cvsroot/boost/boost/libs/intrusive/test
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv27901/test
Modified Files:
list_test.cpp multiset_test.cpp set_test.cpp slist_test.cpp
test_container.hpp unordered_multiset_test.cpp
unordered_set_test.cpp
Added Files:
test_intrusive_associative_container.hpp
test_intrusive_sequence_container.hpp
test_intrusive_unordered_container.hpp
Log Message:
New Intrusive version
--- NEW FILE: test_intrusive_associative_container.hpp ---
--- NEW FILE: test_intrusive_sequence_container.hpp ---
--- NEW FILE: test_intrusive_unordered_container.hpp ---
Index: list_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/list_test.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- list_test.cpp 23 Jun 2007 13:06:49 -0000 1.3
+++ list_test.cpp 22 Jul 2007 14:19:14 -0000 1.4
@@ -20,6 +20,7 @@
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
+#include "test_container.hpp"
using namespace boost::intrusive;
@@ -39,6 +40,20 @@
template<class ValueTraits>
void test_list<ValueTraits>::test_all(std::vector<typename
ValueTraits::value_type>& values)
{
+ typedef boost::intrusive::list
+ < ValueTraits
+ , ValueTraits::value_type::constant_time_size
+ , std::size_t
+ > list_type;
+
+ {
+ list_type list(values.begin(), values.end());
+ test::test_container(list);
+ list.clear();
+ list.insert(list.end(), values.begin(), values.end());
+ test::test_sequence_container(list, values);
+ }
+
test_front_back(values);
test_sort(values);
test_insert(values);
@@ -46,11 +61,6 @@
test_swap(values);
test_clone(values);
- typedef boost::intrusive::list
- < ValueTraits
- , ValueTraits::value_type::constant_time_size
- , std::size_t
- > list_type;
list_type testlist(values.begin(), values.end());
list_type testlist2;
}
Index: multiset_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/multiset_test.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- multiset_test.cpp 23 Jun 2007 13:06:50 -0000 1.3
+++ multiset_test.cpp 22 Jul 2007 14:19:15 -0000 1.4
@@ -19,6 +19,7 @@
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
+#include "test_container.hpp"
using namespace boost::intrusive;
@@ -38,6 +39,24 @@
template<class ValueTraits>
void test_multiset<ValueTraits>::test_all (std::vector<typename
ValueTraits::value_type>& values)
{
+ typedef multiset
+ <ValueTraits
+ ,std::less<typename ValueTraits::value_type>
+ ,ValueTraits::value_type::constant_time_size, std::size_t
+ > multiset_type;
+ {
+ multiset_type testset(values.begin(), values.end());
+ test::test_container(testset);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_common_unordered_and_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_non_unique_container(testset, values);
+ }
test_sort(values);
test_insert(values);
test_swap(values);
Index: set_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/set_test.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- set_test.cpp 23 Jun 2007 13:06:50 -0000 1.3
+++ set_test.cpp 22 Jul 2007 14:19:15 -0000 1.4
@@ -19,6 +19,7 @@
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
+#include "test_container.hpp"
using namespace boost::intrusive;
@@ -38,6 +39,24 @@
template<class ValueTraits>
void test_set<ValueTraits>::test_all(std::vector<typename
ValueTraits::value_type>& values)
{
+ typedef boost::intrusive::set
+ <ValueTraits
+ ,std::less<typename ValueTraits::value_type>
+ ,ValueTraits::value_type::constant_time_size, std::size_t
+ > set_type;
+ {
+ set_type testset(values.begin(), values.end());
+ test::test_container(testset);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_common_unordered_and_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_unique_container(testset, values);
+ }
test_sort(values);
test_insert(values);
test_swap(values);
Index: slist_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/slist_test.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- slist_test.cpp 23 Jun 2007 13:06:50 -0000 1.3
+++ slist_test.cpp 22 Jul 2007 14:19:15 -0000 1.4
@@ -19,6 +19,7 @@
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
+#include "test_container.hpp"
using namespace boost::intrusive;
@@ -41,6 +42,17 @@
void test_slist<ValueTraits>
::test_all (std::vector<typename ValueTraits::value_type>& values)
{
+ typedef boost::intrusive::slist
+ <ValueTraits
+ ,ValueTraits::value_type::constant_time_size, std::size_t
+ > list_type;
+ {
+ list_type list(values.begin(), values.end());
+ test::test_container(list);
+ list.clear();
+ list.insert(list.end(), values.begin(), values.end());
+ test::test_sequence_container(list, values);
+ }
test_front_back (values);
test_sort(values);
test_merge (values);
Index: test_container.hpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/test_container.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- test_container.hpp 23 Jun 2007 13:06:50 -0000 1.3
+++ test_container.hpp 22 Jul 2007 14:19:15 -0000 1.4
@@ -1,119 +1,24 @@
-//////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
//
-// Copyright (c) 2006 Matias Capeletto
-// Copyright (c) 2007 Ion Gaztanaga
+// (C) Copyright Ion Gaztanaga 2007
//
// 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 accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
//
-//////////////////////////////////////////////////////////////////////////////
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_INTRUSIVE_TEST_TEST_CONTAINER_HPP
-#define BOOST_INTRUSIVE_TEST_TEST_CONTAINER_HPP
+#ifndef BOOST_INTRUSIVE_TEST_CONTAINER_HPP
+#define BOOST_INTRUSIVE_TEST_CONTAINER_HPP
-// std
-#include <cassert>
-#include <algorithm>
-#include <vector>
-// Boost.Test
-//#include "boost/test/included/test_exec_monitor.hpp"
+#include <boost/detail/lightweight_test.hpp>
-namespace boost{
-namespace intrusive{
+namespace boost {
+namespace intrusive {
namespace test {
-const int NumElem = 5;
-
-/*
-Beginning of range a.begin() iterator if a is mutable, const_iterator
otherwise [4] [7]
-End of range a.end() iterator if a is mutable, const_iterator otherwise
[4]
-Size a.size() size_type
-Maximum size a.max_size() size_type
-Empty container a.empty() Convertible to bool
-Swap a.swap(b) void
-
-Expression semantics
-Semantics of an expression is defined only where it differs from, or is not
defined in, Assignable, Equality Comparable, or LessThan Comparable Name
Expression Precondition Semantics Postcondition
-Move constructor X(a) X().size() == a.size(). X() contains a copy of
each of a's elements.
-Move constructor X b(a); b.size() == a.size(). b contains a copy of
each of a's elements.
-Move Assignment operator b = a b.size() == a.size(). b contains a copy
of each of a's elements.
-Destructor a.~X() Each of a's elements is disposed, and memory allocated
for them (if any) is deallocated.
-Beginning of range a.begin() Returns an iterator pointing to the first
element in the container. [7] a.begin() is either dereferenceable or
past-the-end. It is past-the-end if and only if a.size() == 0.
-End of range a.end() Returns an iterator pointing one past the last
element in the container. a.end() is past-the-end.
-Size a.size() Returns the size of the container, that is, its number of
elements. [8] a.size() >= 0 && a.size() <= max_size()
-Maximum size a.max_size() Returns the largest size that this container
can ever have. [8] a.max_size() >= 0 && a.max_size() >= a.size()
-Empty container a.empty() Equivalent to a.size() == 0. (But possibly
faster.)
-Swap a.swap(b) Equivalent to swap(a,b) [9]
-*/
-
-/*
-expression return type operational assertion/note
complexity
- semantics pre/post-condition
-
-
-X::value_type T T is
- CopyConstructible
-compile time
-X::reference lvalue of T compile time
-X::const_-
-reference
-const lvalue of T compile time
-X::iterator iterator type
-whose value
-type is T
-any iterator category
-except output iterator.
-convertible to
-X::const_iterator.
-compile time
-X::const_-
-iterator
-constant iterator
-type whose
-value type is T
-any iterator category
-except output iterator
-compile time
-X::difference_
-type
-signed integral
-type
-is identical to the
-difference type of
-X::iterator and
-X::const_iterator
-compile time
-X::size_type unsigned
-integral type
-size_type can
-represent any
-non-negative value of
-compile time
-
-
-
-
-
-
-X u; post: u.size() == 0 constant
-X(); X().size() == 0 constant
-X(a); a == X(a). linear
-X u(a); post: u == a linear
-X u = a; Equivalent to: X u; u
-= a;
-(&a)->X(); void note: the destructor is
-applied to every
-element of a; all the
-memory is deallocated.
-linear
-a.begin(); iterator;
-const_-
-iterator for
-constant a
-constant
-*/
-
template< class Container >
void test_container( Container & c )
{
@@ -126,102 +31,231 @@
typedef typename Container::const_pointer const_pointer;
typedef typename Container::difference_type difference_type;
typedef typename Container::size_type size_type;
+ typedef typename Container::difference_type difference_type;
+ typedef typename Container::size_type size_type;
+ typedef typename Container::value_traits value_traits;
const size_type num_elem = c.size();
- BOOST_CHECK( c.empty() == (num_elem == 0) );
+ BOOST_TEST( c.empty() == (num_elem == 0) );
{
iterator it(c.begin()), itend(c.end());
size_type i;
for(i = 0; i < num_elem; ++i){
++it;
}
- BOOST_CHECK( it == c.end() );
- BOOST_CHECK( c.size() == i );
+ BOOST_TEST( it == c.end() );
+ BOOST_TEST( c.size() == i );
}
+
//Check iterator conversion
- BOOST_CHECK( const_iterator(c.begin()) == c.cbegin() );
+ BOOST_TEST( const_iterator(c.begin()) == c.cbegin() );
{
const_iterator it(c.cbegin()), itend(c.cend());
size_type i;
for(i = 0; i < num_elem; ++i){
++it;
}
- BOOST_CHECK( it == c.cend() );
- BOOST_CHECK( c.size() == i );
+ BOOST_TEST( it == c.cend() );
+ BOOST_TEST( c.size() == i );
}
}
-/*
-template< class Container >
-void test_container
- ( Container & c, typename Container::size_type num_elem
- , Container & c2, typename Container::size_type num_elem2)
+
+
+template< class Container, class Data >
+void test_sequence_container(Container & c, Data & d)
{
- typedef typename Container::value_type value_type;
- typedef typename Container::iterator iterator;
- typedef typename Container::const_iterator const_iterator;
- typedef typename Container::reference reference;
- typedef typename Container::const_reference const_reference;
- typedef typename Container::pointer pointer;
- typedef typename Container::const_pointer const_pointer;
- typedef typename Container::difference_type difference_type;
- typedef typename Container::size_type size_type;
+ assert( d.size() > 2 );
- //For the future:
- //
- //move-copy constructor
- //move-assignment
+ c.clear();
- test_container_helper(c, num_elem);
- test_container_helper(c2, num_elem2);
+ BOOST_TEST( c.size() == 0 );
+ BOOST_TEST( c.empty() );
- //Test swap and test again
- c.swap(c2);
- test_container_helper(c, num_elem2);
- test_container_helper(c2, num_elem);
-}*/
+ c.insert( c.begin(), *d.begin() );
+ c.insert( c.end(), *(++d.begin()) );
-template< class Sequence >
-void test_sequence( Sequence & seq )
+ BOOST_TEST( c.size() == 2 );
+ BOOST_TEST( !c.empty() );
+
+ c.erase( c.begin() );
+
+ BOOST_TEST( c.size() == 1 );
+
+ c.insert( c.begin(), *(++++d.begin()) );
+
+ c.erase( c.begin(), c.end() );
+
+ BOOST_TEST( c.empty() );
+
+ c.insert( c.begin(), *d.begin() );
+
+ BOOST_TEST( c.size() == 1 );
+
+ BOOST_TEST( c.begin() != c.end() );
+
+ c.erase( c.begin() );
+
+ c.assign(d.begin(), d.end());
+
+ BOOST_TEST( c.size() == d.size() );
+
+ c.clear();
+
+ BOOST_TEST( c.size() == 0 );
+ BOOST_TEST( c.empty() );
+}
+
+template< class Container, class Data >
+void test_common_unordered_and_associative_container(Container & c, Data & d)
{
- //First the container requirements
- test_container(seq);
- typedef Sequence::value_type value_type;
- typedef Sequence::iterator iterator;
+ typedef typename Container::size_type size_type;
- Sequence::size_type old_size(seq.size());
+ assert( d.size() > 2 );
- //Now test sequence requirements
- //insert(p, t)
- Sequence::value_type one(1);
- iterator one_pos = seq.insert(seq.begin(), one);
- BOOST_CHECK( &*seq.begin() == &one );
- BOOST_CHECK( seq.size() == (old_size + 1) );
+ c.clear();
+ c.insert(d.begin(), d.end());
- //insert(p, i, j)
- value_type range[2] = { value_type(2), value_type(3) };
- iterator range_it = one_pos; ++range_it;
- seq.insert(range_it, &range[0], &range[2]);
- BOOST_CHECK( seq.size() == (old_size + 3) );
- range_it = ++seq.begin();
- BOOST_CHECK( &*range_it == &range[0] );
- ++range_it;
- BOOST_CHECK( &*range_it == &range[1] );
+ for( typename Data::const_iterator di = d.begin(), de = d.end();
+ di != de; ++di )
+ {
+ BOOST_TEST( c.find(*di) != c.end() );
+ }
- //erase(q)
- iterator it_from_erase = seq.erase(seq.begin());
- BOOST_CHECK( seq.size() == (old_size + 2) );
- BOOST_CHECK( &*it_from_erase == &range[0] );
+ typename Data::const_iterator da = d.begin();
+ typename Data::const_iterator db = ++d.begin();
- //erase(q1, q2)
- iterator q1(it_from_erase), q2(it_from_erase);
- ++++q2;
- it_from_erase = seq.erase(q1, q2);
- BOOST_CHECK( seq.size() == old_size );
- //clear(), assign()???
+ size_type old_size = c.size();
+
+ c.erase(*da);
+
+ BOOST_TEST( c.size() == old_size-1 );
+
+ BOOST_TEST( c.count(*da) == 0 );
+ BOOST_TEST( c.count(*db) != 0 );
+
+ BOOST_TEST( c.find(*da) == c.end() );
+ BOOST_TEST( c.find(*db) != c.end() );
+
+ BOOST_TEST( c.equal_range(*db).first != c.end() );
+
+ c.clear();
+
+ BOOST_TEST( c.equal_range(*da).first == c.end() );
}
-} // namespace test{
-} // namespace intrusive{
-} // namespace boost{
+template< class Container, class Data >
+void test_associative_container_invariants(Container & c, Data & d)
+{
+ typedef typename Container::const_iterator const_iterator;
+ for( typename Data::const_iterator di = d.begin(), de = d.end();
+ di != de; ++di)
+ {
+ const_iterator ci = c.find(*di);
+ BOOST_TEST( ci != c.end() );
+ BOOST_TEST( ! c.value_comp()(*ci, *di) );
+ const_iterator cil = c.lower_bound(*di);
+ const_iterator ciu = c.upper_bound(*di);
+ std::pair<const_iterator, const_iterator> er = c.equal_range(*di);
+ BOOST_TEST( cil == er.first );
+ BOOST_TEST( ciu == er.second );
+ if(ciu != c.end()){
+ BOOST_TEST( c.value_comp()(*cil, *ciu) );
+ }
+ if(c.count(*di) > 1){
+ const_iterator ci_next = cil; ++ci_next;
+ for( ; ci_next != ciu; ++cil, ++ci_next){
+ BOOST_TEST( !c.value_comp()(*ci_next, *cil) );
+ }
+ }
+ }
+}
-#endif // BOOST_INTRUSIVE_TEST_TEST_CONTAINER_HPP
+template< class Container, class Data >
+void test_associative_container(Container & c, Data & d)
+{
+ typedef typename Container::const_iterator const_iterator;
+ assert( d.size() > 2 );
+
+ c.clear();
+ c.insert(d.begin(),d.end());
+
+ test_associative_container_invariants(c, d);
+
+ const Container & cr = c;
+
+ test_associative_container_invariants(cr, d);
+}
+
+template< class Container, class Data >
+void test_unordered_associative_container_invariants(Container & c, Data & d)
+{
+ typedef typename Container::size_type size_type;
+ typedef typename Container::const_iterator const_iterator;
+
+ for( typename Data::const_iterator di = d.begin(), de = d.end() ;
+ di != de ; ++di ){
+ const_iterator i = c.find(*di);
+ size_type nb = c.bucket(*i);
+ size_type bucket_elem = std::distance(c.begin(nb), c.end(nb));
+ BOOST_TEST( bucket_elem == c.bucket_size(nb) );
+ BOOST_TEST( &*c.local_iterator_to(*c.find(*di)) == &*i );
+ std::pair<const_iterator, const_iterator> er = c.equal_range(*di);
+ size_type cnt = std::distance(er.first, er.second);
+ BOOST_TEST( cnt == c.count(*di));
+ if(cnt > 1)
+ for(const_iterator n = er.first, i = n++, e = er.second; n != e; ++i,
++n){
+ BOOST_TEST( c.key_eq()(*i, *n) );
+ BOOST_TEST( c.hash_function()(*i) == c.hash_function()(*n) );
+ }
+ }
+
+ size_type blen = c.bucket_count();
+ size_type total_objects = 0;
+ for(size_type i = 0; i < blen; ++i){
+ total_objects += c.bucket_size(i);
+ }
+ BOOST_TEST( total_objects == c.size() );
+}
+
+template< class Container, class Data >
+void test_unordered_associative_container(Container & c, Data & d)
+{
+ c.clear();
+ c.insert( d.begin(), d.end() );
+
+ test_unordered_associative_container_invariants(c, d);
+
+ const Container & cr = c;
+
+ test_unordered_associative_container_invariants(cr, d);
+}
+
+template< class Container, class Data >
+void test_unique_container(Container & c, Data & d)
+{
+ typedef typename Container::value_type value_type;
+ c.clear();
+ c.insert(d.begin(),d.end());
+ typename Container::size_type old_size = c.size();
+ value_type v(*d.begin());
+ c.insert(v);
+ BOOST_TEST( c.size() == old_size );
+ c.clear();
+}
+
+template< class Container, class Data >
+void test_non_unique_container(Container & c, Data & d)
+{
+ typedef typename Container::value_type value_type;
+ c.clear();
+ c.insert(d.begin(),d.end());
+ typename Container::size_type old_size = c.size();
+ value_type v(*d.begin());
+ c.insert(v);
+ BOOST_TEST( c.size() == (old_size+1) );
+ c.clear();
+}
+
+}}}
+
+#endif //#ifndef BOOST_INTRUSIVE_TEST_CONTAINER_HPP
Index: unordered_multiset_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/unordered_multiset_test.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- unordered_multiset_test.cpp 23 Jun 2007 13:06:50 -0000 1.3
+++ unordered_multiset_test.cpp 22 Jul 2007 14:19:17 -0000 1.4
@@ -21,6 +21,7 @@
#include <set>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
+#include "test_container.hpp"
using namespace boost::intrusive;
@@ -43,6 +44,27 @@
template<class ValueTraits>
void test_unordered_multiset<ValueTraits>::test_all (std::vector<typename
ValueTraits::value_type>& values)
{
+ typedef boost::intrusive::unordered_multiset
+ <ValueTraits
+ ,boost::hash<typename ValueTraits::value_type>
+ ,std::equal_to<typename ValueTraits::value_type>
+ ,ValueTraits::value_type::constant_time_size, std::size_t
+ > unordered_multiset_type;
+ {
+ typename unordered_multiset_type::bucket_type buckets [BucketSize];
+ unordered_multiset_type testset(buckets, BucketSize);
+ testset.insert(values.begin(), values.end());
+ test::test_container(testset);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_common_unordered_and_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_unordered_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_non_unique_container(testset, values);
+ }
test_sort(values);
test_insert(values);
test_swap(values);
Index: unordered_set_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/intrusive/test/unordered_set_test.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- unordered_set_test.cpp 23 Jun 2007 13:06:50 -0000 1.3
+++ unordered_set_test.cpp 22 Jul 2007 14:19:17 -0000 1.4
@@ -20,6 +20,7 @@
#include <set>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
+#include "test_container.hpp"
using namespace boost::intrusive;
@@ -42,6 +43,27 @@
template<class ValueTraits>
void test_unordered_set<ValueTraits>::test_all(std::vector<typename
ValueTraits::value_type>& values)
{
+ typedef boost::intrusive::unordered_set
+ <ValueTraits
+ ,boost::hash<typename ValueTraits::value_type>
+ ,std::equal_to<typename ValueTraits::value_type>
+ ,ValueTraits::value_type::constant_time_size, std::size_t
+ > unordered_set_type;
+ {
+ typename unordered_set_type::bucket_type buckets [BucketSize];
+ unordered_set_type testset(buckets, BucketSize);
+ testset.insert(values.begin(), values.end());
+ test::test_container(testset);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_common_unordered_and_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_unordered_associative_container(testset, values);
+ testset.clear();
+ testset.insert(values.begin(), values.end());
+ test::test_unique_container(testset, values);
+ }
test_sort(values);
test_insert(values);
test_swap(values);
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
