[Boost-commit] svn:boost r56552 - in sandbox/itl: boost/itl libs/itl/test libs/itl/test/test_casual_

Subject: [Boost-commit] svn:boost r56552 - in sandbox/itl: boost/itl libs/itl/test libs/itl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2009-10-03 08:19:14

Author: jofaber
Date: 2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
New Revision: 56552
URL: http://svn.boost.org/trac/boost/changeset/56552

Log:
Boostifying: Replaced 'Tabs' for the latest changes (std::inserter support). Stable {msvc-8.0, 9.0; gcc-3.4.4, 4.1.0} 

Text files modified: 
   sandbox/itl/boost/itl/interval_base_map.hpp            |    12 +++++-----                              
   sandbox/itl/boost/itl/interval_base_set.hpp            |     6 ++--                                    
   sandbox/itl/boost/itl/interval_map.hpp                 |    10 ++++----                                
   sandbox/itl/boost/itl/split_interval_map.hpp           |    10 ++++----                                
   sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp |    20 ++++++++--------                        
   sandbox/itl/libs/itl/test/test_functions.hpp           |    22 +++++++++---------                      
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp |    48 ++++++++++++++++++++--------------------
   7 files changed, 64 insertions(+), 64 deletions(-)

Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp	(original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -414,16 +414,16 @@
     /** Insertion of an \c interval_value_pair into the map. */
     SubType& insert(const segment_type& interval_value_pair)
     { 
-		that()->insert_(interval_value_pair); 
-		return *that(); 
-	}
+        that()->insert_(interval_value_pair); 
+        return *that(); 
+    }
 
     /** Insertion of an \c interval_value_pair into the map. Iterator \c prior_. 
-	    serves as a hint to insert after the element \c prior point to. */
+        serves as a hint to insert after the element \c prior point to. */
     iterator insert(iterator prior_, const segment_type& interval_value_pair)
     { 
-		return that()->insert_(prior_, interval_value_pair);
-	}
+        return that()->insert_(prior_, interval_value_pair);
+    }
 
     /** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
     SubType& set(const element_type& key_value_pair) 

Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp	(original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -116,7 +116,7 @@
     /// const_iterator for iteration over intervals
     typedef typename ImplSetT::const_reverse_iterator const_reverse_iterator;
 
-	typedef typename ImplSetT::pointer                 pointer;
+    typedef typename ImplSetT::pointer                 pointer;
     typedef typename ImplSetT::const_pointer           const_pointer;
     typedef typename ImplSetT::reference               reference;
     typedef typename ImplSetT::const_reference         const_reference;
@@ -295,8 +295,8 @@
     { return add(inter_val); }
 
     /** Insert an interval of elements \c inter_val to the set. Iterator 
-		\c prior_ is a hint to the position \c inter_val can be 
-		inserted after. */
+        \c prior_ is a hint to the position \c inter_val can be 
+        inserted after. */
     iterator insert(iterator prior_, const segment_type& inter_val) 
     { return that()->add_(prior_, inter_val); }
 

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp	(original)
+++ sandbox/itl/boost/itl/interval_map.hpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -632,18 +632,18 @@
         return prior_;
 
     std::pair<iterator,bool> insertion 
-		= this->template map_insert<codomain_combine>(prior_, inter_val, co_val);
+        = this->template map_insert<codomain_combine>(prior_, inter_val, co_val);
 
     if(insertion.second)
-		return join_neighbours(insertion.first);
+        return join_neighbours(insertion.first);
     {
         // Detect the first and the end iterator of the collision sequence
-		std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
+        std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
         iterator it_    = overlap.first,
                  last_  = overlap.second;
-		         --last_;
+                 --last_;
         insert_range(inter_val, co_val, it_, last_);
-		return it_;
+        return it_;
     }
 }
 

Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp	(original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -498,18 +498,18 @@
         return prior_;
 
     std::pair<iterator,bool> insertion 
-		= this->template map_insert<codomain_combine>(prior_, inter_val, co_val);
+        = this->template map_insert<codomain_combine>(prior_, inter_val, co_val);
 
     if(insertion.second)
-		return insertion.first;
+        return insertion.first;
     {
         // Detect the first and the end iterator of the collision sequence
-		std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
+        std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
         iterator it_    = overlap.first,
                  last_  = overlap.second;
-		         --last_;
+                 --last_;
         insert_range(inter_val, co_val, it_, last_);
-		return it_;
+        return it_;
     }
 }
 

Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp	(original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -39,18 +39,18 @@
     typedef interval_map<int,int>       IntervalMapT;
     typedef split_interval_map<int,int> SplitIntervalMapT;
     typedef interval_map<int,int>       IntervalMapT;
-	typedef vector<pair<interval<int>,int> > IntervalVecT;
+    typedef vector<pair<interval<int>,int> > IntervalVecT;
 
-	IntervalVecT ivec;
-	ivec.push_back(make_pair(interval<int>::rightopen(1,3),1));
-	ivec.push_back(make_pair(interval<int>::rightopen(2,4),1));
+    IntervalVecT ivec;
+    ivec.push_back(make_pair(interval<int>::rightopen(1,3),1));
+    ivec.push_back(make_pair(interval<int>::rightopen(2,4),1));
 
-	SplitIntervalMapT sim1, sim2;
-	sim1.insert(make_pair(interval<int>::rightopen(1,3),1));
-	sim1.insert(make_pair(interval<int>::rightopen(2,4),1));
+    SplitIntervalMapT sim1, sim2;
+    sim1.insert(make_pair(interval<int>::rightopen(1,3),1));
+    sim1.insert(make_pair(interval<int>::rightopen(2,4),1));
 
-	IntervalMapT jim1, jim2;
-	std::copy(ivec.begin(), ivec.end(), std::inserter(jim2, jim2.end()));
-	cout << jim2 << endl;
+    IntervalMapT jim1, jim2;
+    std::copy(ivec.begin(), ivec.end(), std::inserter(jim2, jim2.end()));
+    cout << jim2 << endl;
 }
 

Modified: sandbox/itl/libs/itl/test/test_functions.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_functions.hpp	(original)
+++ sandbox/itl/libs/itl/test/test_functions.hpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -31,10 +31,10 @@
           class SequenceT
 >
 void itl_map_copy(const SequenceT& segments, 
-				  IntervalMap<T,U,Trt>& destination)
+                  IntervalMap<T,U,Trt>& destination)
 {
-	ITL_const_FORALL(typename SequenceT, segment_, segments)
-		destination.insert(*segment_);
+    ITL_const_FORALL(typename SequenceT, segment_, segments)
+        destination.insert(*segment_);
 }
 
 
@@ -51,14 +51,14 @@
 >
 void test_interval_map_copy_via_inserter(const SequenceT& segments, IntervalMap<T,U,Trt>& std_copied_map)
 {
-	// The second parameter (std_copied_map) could be omitted and only held as a 
-	// local variable. I is there to help gcc-3.4.4 resolving the function template type.
-	typedef IntervalMap<T,U,Trt> IntervalMapT;
-	IntervalMapT looped_copied_map;
-	std_copied_map.clear();
-	itl_map_copy(segments, looped_copied_map);
-	std::copy(segments.begin(), segments.end(), std::inserter(std_copied_map, std_copied_map.end()));
-	BOOST_CHECK_EQUAL( looped_copied_map, std_copied_map );
+    // The second parameter (std_copied_map) could be omitted and only held as a 
+    // local variable. I is there to help gcc-3.4.4 resolving the function template type.
+    typedef IntervalMap<T,U,Trt> IntervalMapT;
+    IntervalMapT looped_copied_map;
+    std_copied_map.clear();
+    itl_map_copy(segments, looped_copied_map);
+    std::copy(segments.begin(), segments.end(), std::inserter(std_copied_map, std_copied_map.end()));
+    BOOST_CHECK_EQUAL( looped_copied_map, std_copied_map );
 }
 
 }} // namespace itl boost

Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp	(original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp	2009-10-03 08:19:13 EDT (Sat, 03 Oct 2009)
@@ -1207,30 +1207,30 @@
 {
     typedef IntervalMap<T,U,Trt> IntervalMapT; //Nedded for the test value generator
 
-	// Check equality of copying using handcoded loop or std::copy via inserter.
-	typedef std::pair<interval<T>, U> SegmentT;
-	std::vector<SegmentT> seg_vec_a;
-	IntervalMapT std_copied_map;
-
-	// For an empty sequence
-	test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
-
-	// For an singleton sequence
-	seg_vec_a.push_back(IDv(0,1,1));
-	test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
-
-	// Two separate segments
-	seg_vec_a.push_back(IDv(3,5,1));
-	test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
-
-	// Touching case
-	seg_vec_a.push_back(IDv(5,7,1));
-	test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
-
-	// Overlapping case
-	seg_vec_a.push_back(IDv(6,9,1));
-	test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
-	
+    // Check equality of copying using handcoded loop or std::copy via inserter.
+    typedef std::pair<interval<T>, U> SegmentT;
+    std::vector<SegmentT> seg_vec_a;
+    IntervalMapT std_copied_map;
+
+    // For an empty sequence
+    test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
+
+    // For an singleton sequence
+    seg_vec_a.push_back(IDv(0,1,1));
+    test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
+
+    // Two separate segments
+    seg_vec_a.push_back(IDv(3,5,1));
+    test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
+
+    // Touching case
+    seg_vec_a.push_back(IDv(5,7,1));
+    test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
+
+    // Overlapping case
+    seg_vec_a.push_back(IDv(6,9,1));
+    test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
+    
 }