replace tabs with 4 spaces in all files

git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@600 7ec92016-0320-0410-acc4-a06ded1c099a

include/loki/yasli/yasli_fill_iterator.h

@@ -10,10 +10,10 @@ namespace yasli_nstd
 	class fill_iterator_base
         : public std::iterator<
             std::random_access_iterator_tag,
-		    T,
-		    ptrdiff_t,
-		    T*,
-		    T&>
+            T,
+            ptrdiff_t,
+            T*,
+            T&>
     {
     };
 
@@ -21,112 +21,112 @@ namespace yasli_nstd
 	class fill_iterator_base<T&>
         : public std::iterator<
             std::random_access_iterator_tag,
-		    T,
-		    ptrdiff_t,
-		    T*,
-		    T&>
+            T,
+            ptrdiff_t,
+            T*,
+            T&>
     {
     };
 
     template <class T>
     class fill_iterator : public fill_iterator_base<T>
-	{
+    {
         T value_;
         /*difference_type*/ ptrdiff_t count_;//////////////////////////////////
     
     public:
         typedef std::ptrdiff_t difference_type;
         typedef typename fill_iterator_base<T>::pointer pointer;
-	    typedef typename fill_iterator_base<T>::reference reference;
-	    //typedef iterator_type;
+        typedef typename fill_iterator_base<T>::reference reference;
+        //typedef iterator_type;
 
-	    fill_iterator()
-		{	
-		}
+        fill_iterator()
+        {    
+        }
 
-	    explicit fill_iterator(reference value, difference_type count = 0)
-		: value_(value), count_(count)
-		{	
-		}
+        explicit fill_iterator(reference value, difference_type count = 0)
+        : value_(value), count_(count)
+        {    
+        }
 
-	    template<class U>
-		fill_iterator(const fill_iterator<U>& rhs)
-		: value_(rhs.value_), count_(rhs.count_)
-		{
-		}
-
-	    reference operator*() const
-		{
-		    return value_;
-		}
-
-	    pointer operator->() const
+        template<class U>
+    	fill_iterator(const fill_iterator<U>& rhs)
+        : value_(rhs.value_), count_(rhs.count_)
         {
-		    return &**this;
-		}
+        }
 
-	    fill_iterator& operator++()
-		{	
+        reference operator*() const
+        {
+            return value_;
+        }
+
+        pointer operator->() const
+        {
+            return &**this;
+        }
+
+        fill_iterator& operator++()
+        {    
             ++count_;
-		    return *this;
-		}
+            return *this;
+        }
 
-	    fill_iterator operator++(int)
+        fill_iterator operator++(int)
         {
-		    fill_iterator it(*this);
+            fill_iterator it(*this);
             ++*this;
-		    return it;
+            return it;
         }
 
-	    fill_iterator& operator--()
-		{	
+        fill_iterator& operator--()
+        {    
             --count_;
-		    return *this;
-		}
-
-	    fill_iterator operator--(int)
-        {
-		    fill_iterator it(*this);
-            --*this;
-		    return it;
+            return *this;
         }
 
-	    fill_iterator& operator+=(difference_type d)
-		{
-		    count_ += d;
-		    return *this;
-		}
+        fill_iterator operator--(int)
+        {
+            fill_iterator it(*this);
+            --*this;
+            return it;
+        }
 
-	    fill_iterator operator+(difference_type d) const
-		{
-		    return fill_iterator(*this) += d;
-		}
+        fill_iterator& operator+=(difference_type d)
+        {
+            count_ += d;
+            return *this;
+        }
 
-	    fill_iterator& operator-=(difference_type d)
-		{
-		    count_ -= d;
-		    return *this;
-		}
+        fill_iterator operator+(difference_type d) const
+        {
+            return fill_iterator(*this) += d;
+        }
 
-	    fill_iterator operator-(difference_type d) const
-		{
-		    return fill_iterator(*this) -= d;
-		}
+        fill_iterator& operator-=(difference_type d)
+        {
+            count_ -= d;
+            return *this;
+        }
+
+        fill_iterator operator-(difference_type d) const
+        {
+            return fill_iterator(*this) -= d;
+        }
 
         difference_type operator-(const fill_iterator<T>& rhs) const
         {
-	        return count_ - rhs.count_;
+            return count_ - rhs.count_;
         }
 
-	    reference operator[](difference_type) const
-		{
-		    return **this;
-		}
+        reference operator[](difference_type) const
+        {
+            return **this;
+        }
 
         template <class T2> 
         bool operator==(const fill_iterator<T2>& rhs) const
-	    {
-	        return count_ == rhs.count_;
+        {
+            return count_ == rhs.count_;
         }
 
     };
@@ -134,21 +134,21 @@ namespace yasli_nstd
     template <class T, class D> 
     inline fill_iterator<T> operator+(D lhs, const fill_iterator<T>& rhs)
     {
-	    return rhs + lhs;
-	}
+        return rhs + lhs;
+    }
 
     template <class T> 
     inline bool operator!=(
         const fill_iterator<T>& lhs,
-		const fill_iterator<T>& rhs)
-    {	// test for fill_iterator inequality
+    	const fill_iterator<T>& rhs)
+    {    // test for fill_iterator inequality
         return !(lhs == rhs);
     }
 
     template <class T> 
     inline bool operator<(
         const fill_iterator<T>& lhs,
-		const fill_iterator<T>& rhs)
+    	const fill_iterator<T>& rhs)
     {
         return lhs.count_ < rhs.count_;
     }
@@ -156,7 +156,7 @@ namespace yasli_nstd
     template <class T> 
     inline bool operator>(
         const fill_iterator<T>& lhs,
-	    const fill_iterator<T>& rhs)
+        const fill_iterator<T>& rhs)
     {
         return rhs < lhs;
     }
@@ -164,7 +164,7 @@ namespace yasli_nstd
     template <class T> 
     inline bool operator<=(
         const fill_iterator<T>& lhs,
-	    const fill_iterator<T>& rhs)
+        const fill_iterator<T>& rhs)
     {
         return !(rhs < lhs);
     }

include/loki/yasli/yasli_traits.h

@@ -60,7 +60,7 @@ namespace yasli_nstd
         enum { value = int(!is_class<T>::value) };
     };
 
-	
+    
    template <typename T> struct is_memmoveable
     {
         enum { value = int(!is_class<T>::value) };

include/loki/yasli/yasli_vector.h

@@ -316,13 +316,13 @@ namespace yasli {
        }
        const_reference at(size_type n) const
        {
-		   // Fix by Joseph Canedo
+           // Fix by Joseph Canedo
            if (n >= size()) throw std::range_error("vector<>::at");
            return ebo_.beg_[n];
        }
        reference at(size_type n)
        {
-		   // Fix by Joseph Canedo
+           // Fix by Joseph Canedo
            if (n >= size()) throw std::range_error("vector<>::at");
            return ebo_.beg_[n];
        }