[Boost-commit] svn:boost r54493 - in sandbox/monotonic: boost libs/monotonic/test/clones

Subject: [Boost-commit] svn:boost r54493 - in sandbox/monotonic: boost libs/monotonic/test/clones
From: christian.schladetsch_at_[hidden]
Date: 2009-06-28 20:51:35

Author: cschladetsch
Date: 2009-06-28 20:51:34 EDT (Sun, 28 Jun 2009)
New Revision: 54493
URL: http://svn.boost.org/trac/boost/changeset/54493

Log:
removed tabs from any.hpp

Text files modified: 
   sandbox/monotonic/boost/any.hpp                        |   154 +++++++++++++++++++-------------------  
   sandbox/monotonic/libs/monotonic/test/clones/tests.cpp |     6                                         
   2 files changed, 80 insertions(+), 80 deletions(-)

Modified: sandbox/monotonic/boost/any.hpp
==============================================================================
--- sandbox/monotonic/boost/any.hpp	(original)
+++ sandbox/monotonic/boost/any.hpp	2009-06-28 20:51:34 EDT (Sun, 28 Jun 2009)
@@ -16,7 +16,7 @@
 #include "boost/config.hpp"
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_reference.hpp>
-#include <boost/throw_exception.hpp>
+#include <boost/throw_exception.hp>p
 #include <boost/static_assert.hpp>
 
 namespace boost
@@ -24,52 +24,52 @@
     template <class Alloc = std::allocator<char> >
     class any
     {
-		typedef Alloc allocator_type;
-		typedef any<allocator_type> any_type;
+        typedef Alloc allocator_type;
+        typedef any<allocator_type> any_type;
 
-		template <class U>
-		U *allocate_type()
-		{
-			typename allocator_type::template rebind<U>::other alloc(get_allocator());
-			return alloc.allocate(1);
-		}
-
-		template <class U>
-		U *construct_type()
-		{
-			typename allocator_type::template rebind<U>::other alloc(get_allocator());
-			U *ptr = alloc.allocate(1);
-			alloc.construct(ptr);
-			return ptr;
-		}
-		template <class U, class A0>
-		U *construct_type(A0 a0)
-		{
-			typename allocator_type::template rebind<U>::other alloc(get_allocator());
-			U *ptr = alloc.allocate(1);
-			new (ptr) U(a0);
-			return ptr;
-		}
-		template <class U, class A0, class A1>
-		U *construct_type(A0 a0, A1 a1)
-		{
-			typename allocator_type::template rebind<U>::other alloc(get_allocator());
-			U *ptr = alloc.allocate(1);
-			new (ptr) U(a0, a1);
-			return ptr;
-		}
-		template <class U>
-		void destroy_type(U *ptr)
-		{
-			typename allocator_type::template rebind<U>::other alloc(get_allocator());
-			alloc.destroy(ptr);
-		}
-		template <class U>
-		void deallocate_type(U *ptr)
-		{
-			typename allocator_type::template rebind<U>::other alloc(get_allocator());
-			alloc.deallocate(ptr, 1);
-		}
+        template <class U>
+        U *allocate_type()
+        {
+            typename allocator_type::template rebind<U>::other alloc(get_allocator());
+            return alloc.allocate(1);
+        }
+
+        template <class U>
+        U *construct_type()
+        {
+            typename allocator_type::template rebind<U>::other alloc(get_allocator());
+            U *ptr = alloc.allocate(1);
+            alloc.construct(ptr);
+            return ptr;
+        }
+        template <class U, class A0>
+        U *construct_type(A0 a0)
+        {
+            typename allocator_type::template rebind<U>::other alloc(get_allocator());
+            U *ptr = alloc.allocate(1);
+            new (ptr) U(a0);
+            return ptr;
+        }
+        template <class U, class A0, class A1>
+        U *construct_type(A0 a0, A1 a1)
+        {
+            typename allocator_type::template rebind<U>::other alloc(get_allocator());
+            U *ptr = alloc.allocate(1);
+            new (ptr) U(a0, a1);
+            return ptr;
+        }
+        template <class U>
+        void destroy_type(U *ptr)
+        {
+            typename allocator_type::template rebind<U>::other alloc(get_allocator());
+            alloc.destroy(ptr);
+        }
+        template <class U>
+        void deallocate_type(U *ptr)
+        {
+            typename allocator_type::template rebind<U>::other alloc(get_allocator());
+            alloc.deallocate(ptr, 1);
+        }
     public: // structors
 
         any()
@@ -77,37 +77,37 @@
         {
         }
 
-		template<typename ValueType>
-		any(const ValueType & value)
-		{
-			content = construct_holder<ValueType>(value);
-		}
-		
-		template<typename ValueType, class Al>
+        template<typename ValueType>
+        any(const ValueType & value)
+        {
+            content = construct_holder<ValueType>(value);
+        }
+        
+        template<typename ValueType, class Al>
         any(const ValueType & value, Al al)
           : alloc(al)
         {
-			content = construct_holder<ValueType>(value);
-		}
+            content = construct_holder<ValueType>(value);
+        }
 
         any(const any & other)
           : alloc(other.alloc)
         {
-			content = other.content ? other.content->clone() : 0;
+            content = other.content ? other.content->clone() : 0;
         }
 
         ~any()
         {
-			destroy_type(content);
-			deallocate_type(content);
+            destroy_type(content);
+            deallocate_type(content);
         }
 
     public: // modifiers
 
         any & swap(any & rhs)
         {
-			std::swap(content, rhs.content);
-			//std::swap(alloc, rhs.alloc);
+            std::swap(content, rhs.content);
+            //std::swap(alloc, rhs.alloc);
             return *this;
         }
 
@@ -131,10 +131,10 @@
             return !content;
         }
 
-		allocator_type get_allocator() const
-		{
-			return alloc;
-		}
+        allocator_type get_allocator() const
+        {
+            return alloc;
+        }
 
         const std::type_info & type() const
         {
@@ -182,13 +182,13 @@
 
             virtual placeholder * clone() const
             {
-				return parent->construct_holder<ValueType>(held);
+                return parent->construct_holder<ValueType>(held);
             }
 
         public: // representation
 
-			any_type *parent;
-			ValueType held;
+            any_type *parent;
+            ValueType held;
 
         private: // intentionally left unimplemented
             holder & operator=(const holder &);
@@ -197,14 +197,14 @@
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 
     private: // representation
-		template <class U>
-		holder<U> *construct_holder(U const &init)
-		{
-			typename allocator_type::template rebind<holder<U> >::other alloc(get_allocator());
-			holder<U> *ptr = alloc.allocate(1);
-			new (ptr) holder<U>(init, *this);
-			return ptr;
-		}
+        template <class U>
+        holder<U> *construct_holder(U const &init)
+        {
+            typename allocator_type::template rebind<holder<U> >::other alloc(get_allocator());
+            holder<U> *ptr = alloc.allocate(1);
+            new (ptr) holder<U>(init, *this);
+            return ptr;
+        }
 
         template<typename ValueType, class Al9>
         friend ValueType * any_cast(any<Al9> *);
@@ -218,7 +218,7 @@
 
 #endif
 
-		allocator_type alloc;
+        allocator_type alloc;
         placeholder * content;
 
     };
@@ -240,7 +240,7 @@
         typedef typename any_type::template holder<ValueType> holder_type;
         return operand && operand->type() == typeid(ValueType)
                     ? &static_cast<holder_type *>
-		(operand->content)->held
+        (operand->content)->held
                     : 0;
     }
 

Modified: sandbox/monotonic/libs/monotonic/test/clones/tests.cpp
==============================================================================
--- sandbox/monotonic/libs/monotonic/test/clones/tests.cpp	(original)
+++ sandbox/monotonic/libs/monotonic/test/clones/tests.cpp	2009-06-28 20:51:34 EDT (Sun, 28 Jun 2009)
@@ -21,7 +21,7 @@
 {
         int num;
         derived() : num(0) { }
-	explicit derived(int n) : num(n) { }
+	derived(int n) : num(n) { }
 };
 
 struct derived2 : base<derived2>
@@ -29,7 +29,7 @@
         std::string str;
 
         derived2() { }
-	explicit derived2(std::string const &n) : str(n) { }
+	derived2(std::string const &n) : str(n) { }
 };
 
 struct derived3 : base<derived3>
@@ -39,7 +39,7 @@
         std::string str;
 
         derived3() { }
-	explicit derived3(float f, int n, std::string const &s) : real(f), num(n), str(s) { }
+	derived3(float f, int n, std::string const &s) : real(f), num(n), str(s) { }
 
         void print() const
         {