[Boost-commit] svn:boost r68455 - sandbox/guild/pool/boost/pool

Subject: [Boost-commit] svn:boost r68455 - sandbox/guild/pool/boost/pool
From: pbristow_at_[hidden]
Date: 2011-01-26 11:58:30

Author: pbristow
Date: 2011-01-26 11:58:29 EST (Wed, 26 Jan 2011)
New Revision: 68455
URL: http://svn.boost.org/trac/boost/changeset/68455

Log:
Tabs removed.
Text files modified: 
   sandbox/guild/pool/boost/pool/object_pool.hpp |    18 +++++++++---------                      
   sandbox/guild/pool/boost/pool/pool_alloc.hpp  |    40 ++++++++++++++++++++--------------------
   2 files changed, 29 insertions(+), 29 deletions(-)

Modified: sandbox/guild/pool/boost/pool/object_pool.hpp
==============================================================================
--- sandbox/guild/pool/boost/pool/object_pool.hpp	(original)
+++ sandbox/guild/pool/boost/pool/object_pool.hpp	2011-01-26 11:58:29 EST (Wed, 26 Jan 2011)
@@ -85,8 +85,8 @@
     // for the sake of code readability :)
     static void * & nextof(void * const ptr)
     { //! \returns dereferenced ptr (for the sake of code readability :)
-			return *(static_cast<void **>(ptr));
-		}
+      return *(static_cast<void **>(ptr));
+    }
 
   public:
     explicit object_pool(const size_type next_size = 32, const size_type max_size = 0)
@@ -96,7 +96,7 @@
       //! \param next_size number of chunks to request from the system the next time that object needs to allocate system memory (default 32).
       //! \pre next_size != 0.
       //! \param max_size maximum size of block.
-		}
+    }
 
     ~object_pool();
 
@@ -104,14 +104,14 @@
     element_type * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
     { //! Allocates memory that can hold one object of type ElementType.
       //! If out of memory, returns 0. Amortized O(1).
-			return static_cast<element_type *>(store().ordered_malloc());
-		}
+      return static_cast<element_type *>(store().ordered_malloc());
+    }
     void free BOOST_PREVENT_MACRO_SUBSTITUTION(element_type * const chunk)
     { //! De-Allocates memory that holds a chunk of type ElementType.
       //!  Note that p may not be 0.\n
       //! Note that the destructor for p is not called. O(N).
-			store().ordered_free(chunk);
-		}
+      store().ordered_free(chunk);
+    }
     bool is_from(element_type * const chunk) const
     { /*! \returns true  if p was allocated from u or
       may be returned as the result of a future allocation from u.
@@ -120,8 +120,8 @@
       Otherwise, the return value is meaningless.
       Note that this function may not be used to reliably test random pointer values!
     */
-			return store().is_from(chunk);
-		}
+      return store().is_from(chunk);
+    }
 
     element_type * construct()
     { //! Constructs a new

Modified: sandbox/guild/pool/boost/pool/pool_alloc.hpp
==============================================================================
--- sandbox/guild/pool/boost/pool/pool_alloc.hpp	(original)
+++ sandbox/guild/pool/boost/pool/pool_alloc.hpp	2011-01-26 11:58:29 EST (Wed, 26 Jan 2011)
@@ -24,18 +24,18 @@
   They also both satisfy the additional requirements found in [20.1.5/4];
   this permits their usage with any Standard-compliant container.
 
-	In addition, the fast_pool_allocator also provides an additional allocation
-	and an additional deallocation function:
+  In addition, the fast_pool_allocator also provides an additional allocation
+  and an additional deallocation function:
 
-	Symbol Table\n
-	Symbol	Meaning\n
-	PoolAlloc	fast_pool_allocator<T, UserAllocator>\n
-	p	value of type T *\n
-	\n
-	Additional allocation/deallocation functions (fast_pool_allocator only)\n
-	Expression	Return Type	Semantic Equivalence\n
-	PoolAlloc::allocate()	T *	PoolAlloc::allocate(1)\n
-	PoolAlloc::deallocate(p)	void	PoolAlloc::deallocate(p, 1)\n
+  Symbol Table\n
+  Symbol	Meaning\n
+  PoolAlloc	fast_pool_allocator<T, UserAllocator>\n
+  p	value of type T *\n
+  \n
+  Additional allocation/deallocation functions (fast_pool_allocator only)\n
+  Expression	Return Type	Semantic Equivalence\n
+  PoolAlloc::allocate()	T *	PoolAlloc::allocate(1)\n
+  PoolAlloc::deallocate(p)	void	PoolAlloc::deallocate(p, 1)\n
 
 The typedef user_allocator publishes the value of the UserAllocator template parameter.
 
@@ -224,14 +224,14 @@
 
  /*! Fast Pool memory allocator.
 
-	pool_allocator is a more general-purpose solution, geared towards
-	efficiently servicing requests for any number of contiguous chunks.
-	fast_pool_allocator is also a general-purpose solution,
-	but is geared towards efficiently servicing requests for one chunk at a time;
-	it will work for contiguous chunks, but not as well as pool_allocator.
-	If you are seriously concerned about performance,
-	use fast_pool_allocator when dealing with containers such as std::list,
-	and use pool_allocator when dealing with containers such as std::vector.
+  pool_allocator is a more general-purpose solution, geared towards
+  efficiently servicing requests for any number of contiguous chunks.
+  fast_pool_allocator is also a general-purpose solution,
+  but is geared towards efficiently servicing requests for one chunk at a time;
+  it will work for contiguous chunks, but not as well as pool_allocator.
+  If you are seriously concerned about performance,
+  use fast_pool_allocator when dealing with containers such as std::list,
+  and use pool_allocator when dealing with containers such as std::vector.
 */
 template <typename T,
     typename UserAllocator,
@@ -253,7 +253,7 @@
     typedef typename pool<UserAllocator>::size_type size_type;
     typedef typename pool<UserAllocator>::difference_type difference_type;
 
-		//! ???  TODO rebind description needed.
+    //! ???  TODO rebind description needed.
     template <typename U>
     struct rebind
     {