svn commit: [25973] trunk/uClibc++/include

[aldot at uclibc.org]

Author: aldot
Date: 2009-04-06 08:15:49 +0000 (Mon, 06 Apr 2009)
New Revision: 25973

Log:
- commentary typo fixes and whitespace cleanup


Modified:
   trunk/uClibc++/include/associative_base


Changeset:
Modified: trunk/uClibc++/include/associative_base
===================================================================
--- trunk/uClibc++/include/associative_base	2009-04-06 08:06:36 UTC (rev 25972)
+++ trunk/uClibc++/include/associative_base	2009-04-06 08:15:49 UTC (rev 25973)
@@ -34,11 +34,11 @@
 
 
 /*
- *	The basic premise here is that most of the code used by map, multimap, set and 
+ *	The basic premise here is that most of the code used by map, multimap, set and
  *	multiset is really common.  There are a number of interface additions, and
  *	considerations about how to address multiple entries with the same key.
  *	The goal is that the tree/storage code should be here, and managing
- * 	single or multiple counts will be left to subclasses.
+ *	single or multiple counts will be left to subclasses.
  *	Yes, inheritence for the purpose of code sharing is usually a bad idea.
  *	However, since our goal is to reduce the total amount of code written
  *	and the overall binary size, this seems to be the best approach possible.
@@ -234,7 +234,7 @@
 
 
 /*
- * Tree interators for the base associative class
+ * Tree iterators for the base associative class
  */
 
 template<class ValueType, class Compare, class Allocator> class _associative_citer
@@ -279,7 +279,7 @@
 		return *this;
 	}
 	_associative_citer operator++(int){
-		//The following approach ensures that we only need to 
+		//The following approach ensures that we only need to
 		//provide code for ++ in one place (above)
 		_associative_citer temp(base_iter);
 		++base_iter;
@@ -290,7 +290,7 @@
 		return *this;
 	}
 	_associative_citer operator--(int){
-		//The following approach ensures that we only need to 
+		//The following approach ensures that we only need to
 		//provide code for -- in one place (above)
 		_associative_citer temp(base_iter);
 		--base_iter;
@@ -301,7 +301,6 @@
 	typename listtype::const_iterator base_iterator(){
 		return base_iter;
 	}
-	
 };
 
 
@@ -320,7 +319,6 @@
 	typename listtype::iterator base_iter;
 	typedef _associative_citer<ValueType, Compare, Allocator> _associative_citer;
 
-	
 public:
 	_associative_iter() { }
 	_associative_iter(const _associative_iter & m)
@@ -361,7 +359,7 @@
 		return *this;
 	}
 	_associative_iter operator++(int){
-		//The following approach ensures that we only need to 
+		//The following approach ensures that we only need to
 		//provide code for ++ in one place (above)
 		_associative_iter temp(base_iter);
 		++base_iter;
@@ -372,7 +370,7 @@
 		return *this;
 	}
 	_associative_iter operator--(int){
-		//The following approach ensures that we only need to 
+		//The following approach ensures that we only need to
 		//provide code for -- in one place (above)
 		_associative_iter temp(base_iter);
 		--base_iter;
@@ -392,7 +390,7 @@
 
 
 	// The lower_bound code is really crappy linear search.  However, it is a dead
-	// simple implimentation (easy to audit).  It can also be easily replaced.
+	// simple implementation (easy to audit).  It can also be easily replaced.
 
 
 	template <class Key, class ValueType, class Compare, class Allocator>
@@ -418,7 +416,7 @@
 	}
 
 	// Upper bound search is linear from the point of lower_bound.  This is likely the best solution
-	// in all but the most pathalogical of cases.
+	// in all but the most pathological of cases.
 
 	template <class Key, class ValueType, class Compare, class Allocator>
 		typename __base_associative<Key, ValueType, Compare, Allocator>::iterator
@@ -533,7 +531,7 @@
 	}
 
 	iterator insert(iterator position, const value_type& x){
-		// FIXME - this is cheeting and probably should be more efficient since we are
+		// FIXME - this is cheating and probably should be more efficient since we are
 		// now log(n) to find for inserts
 		return insert(x).first;
 	}
@@ -618,7 +616,7 @@
 	}
 
 	iterator insert(iterator position, const value_type& x){
-		// FIXME - this is cheeting and probably should be more efficient since we are
+		// FIXME - this is cheating and probably should be more efficient since we are
 		// now log(n) to find for inserts
 		return insert(x);
 	}
@@ -640,4 +638,3 @@
 
 #endif	//__STD_HEADER_ASSOCIATIVE_BASE
 
-