[Boost-commit] svn:boost r52631 - in sandbox/SOC/2009/fusion: . mini-fusion workaround/conceptgcc

Subject: [Boost-commit] svn:boost r52631 - in sandbox/SOC/2009/fusion: . mini-fusion workaround/conceptgcc
From: mr.chr.schmidt_at_[hidden]
Date: 2009-04-27 12:05:09

Author: cschmidt
Date: 2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
New Revision: 52631
URL: http://svn.boost.org/trac/boost/changeset/52631

Log:
tabs -> whitespaces
Text files modified: 
   sandbox/SOC/2009/fusion/build.bat                     |    30                                         
   sandbox/SOC/2009/fusion/mini-fusion/categories.hpp    |    12                                         
   sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp      |   126 +++---                                  
   sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp   |   658 ++++++++++++++++++------------------    
   sandbox/SOC/2009/fusion/mini-fusion/test.cpp          |   232 ++++++------                            
   sandbox/SOC/2009/fusion/mini-fusion/vector.hpp        |   724 ++++++++++++++++++++--------------------
   sandbox/SOC/2009/fusion/workaround/conceptgcc/utility |    94 ++--                                    
   7 files changed, 938 insertions(+), 938 deletions(-)

Modified: sandbox/SOC/2009/fusion/build.bat
==============================================================================
--- sandbox/SOC/2009/fusion/build.bat	(original)
+++ sandbox/SOC/2009/fusion/build.bat	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -11,22 +11,22 @@
 
 rem call toolset specific procedure
 if "%1" == "conceptgcc" (
-	call :conceptgcc
+    call :conceptgcc
 ) else (
-	if "%1" == "gcc" (
-		call :gcc
-	) else (
-		if "%1" == "msvc" (
-			call :msvc
-		) else (
-			if "%1" == "" (
-				call :conceptgcc
-			) else (
-				echo Unknown toolset '%1'
-				goto :eof
-			)
-		)
-	)
+    if "%1" == "gcc" (
+        call :gcc
+    ) else (
+        if "%1" == "msvc" (
+            call :msvc
+        ) else (
+            if "%1" == "" (
+                call :conceptgcc
+            ) else (
+                echo Unknown toolset '%1'
+                goto :eof
+            )
+        )
+    )
 )
 
 rem compile...

Modified: sandbox/SOC/2009/fusion/mini-fusion/categories.hpp
==============================================================================
--- sandbox/SOC/2009/fusion/mini-fusion/categories.hpp	(original)
+++ sandbox/SOC/2009/fusion/mini-fusion/categories.hpp	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -5,11 +5,11 @@
 #pragma once
 
 namespace boost{namespace fusion{namespace gsoc{
-	class forward_iterator_category;
-	class bidirectional_iterator_category;
-	class random_access_iterator_category;
+    class forward_iterator_category;
+    class bidirectional_iterator_category;
+    class random_access_iterator_category;
 
-	class forward_sequence_category;
-	class bidirectional_sequence_category;
-	class random_access_sequence_category;
+    class forward_sequence_category;
+    class bidirectional_sequence_category;
+    class random_access_sequence_category;
 }}}

Modified: sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp
==============================================================================
--- sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp	(original)
+++ sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -11,67 +11,67 @@
 #include <boost/mpl/bool.hpp>
 
 namespace boost{namespace fusion{namespace gsoc{
-	//Fusion-iterators and sequences are defined through a set of (meta-)functions rather than their own public interface.
-	//Unfortunately some of these (meta-)functions are not valid for specific valid types (e.g. next is invalid on an end
-	//iterator). We also need arguments for most (meta-)functions, which cannot be provided easily in the context of a concept.
-	//Therefore we ignore these (meta-)functions here.
-
-	namespace detail
-	{
-		typedef mpl::vector<forward_iterator_category,bidirectional_iterator_category,random_access_iterator_category> forward_iterator_categories;
-		typedef mpl::vector<bidirectional_iterator_category,random_access_iterator_category> bidirectional_iterator_categories;
-		typedef mpl::vector<random_access_iterator_category> random_access_iterator_categories;
-	}
-
-	auto concept ForwardIterator<class Iterator> :
-			std::CopyConstructible<Iterator>//, std::HasEqualTo<Iterator,Iterator>, std::HasNotEqualTo<Iterator,Iterator>
-	{
-		typename tag=typename Iterator::tag;
-		typename category=typename Iterator::category;
-
-		//requires std::SameType<mpl::contains<detail::forward_iterator_categories,tag>::type,mpl::true_>; segfaults in ConceptGCC!
-		typename detail_is_valid=typename mpl::contains<detail::forward_iterator_categories,category>::type;
-		requires std::SameType<detail_is_valid,mpl::true_>;
-	}
-
-	auto concept BidirectionalIterator<class Iterator> : ForwardIterator<Iterator>
-	{
-		typename detail_is_valid=typename mpl::contains<detail::bidirectional_iterator_categories,category>::type;
-		requires std::SameType<detail_is_valid,mpl::true_>;
-	}
-
-	auto concept RandomAccessIterator<class Iterator> : BidirectionalIterator<Iterator>
-	{
-		typename detail_is_valid=typename mpl::contains<detail::random_access_iterator_categories,category>::type;
-		requires std::SameType<detail_is_valid,mpl::true_>;
-	}
-
-	namespace detail
-	{
-		typedef mpl::vector<forward_sequence_category,bidirectional_sequence_category,random_access_sequence_category> forward_sequence_categories;
-		typedef mpl::vector<bidirectional_sequence_category,random_access_sequence_category> bidirectional_sequence_categories;
-		typedef mpl::vector<random_access_sequence_category> random_access_sequence_categories;
-	}
-
-	auto concept ForwardSequence<class Sequence> :
-		std::CopyConstructible<Sequence>//, std::HasEqualTo<Sequence,Sequence>, std::HasNotEqualTo<Sequence,Sequence>
-	{
-		typename tag=typename Sequence::tag;
-		typename category=typename Sequence::category;
-
-		typename detail_is_valid=typename mpl::contains<detail::forward_sequence_categories,category>::type;
-		requires std::SameType<detail_is_valid,mpl::true_>;
-	}
-
-	auto concept BidirectionalSequence<class Sequence> : ForwardSequence<Sequence>
-	{
-		typename detail_is_valid=typename mpl::contains<detail::bidirectional_sequence_categories,category>::type;
-		requires std::SameType<detail_is_valid,mpl::true_>;
-	}
-
-	auto concept RandomAccessSequence<class Sequence> : BidirectionalSequence<Sequence>
-	{
-		typename detail_is_valid=typename mpl::contains<detail::random_access_sequence_categories,category>::type;
-		requires std::SameType<detail_is_valid,mpl::true_>;
-	}
+    //Fusion-iterators and sequences are defined through a set of (meta-)functions rather than their own public interface.
+    //Unfortunately some of these (meta-)functions are not valid for specific valid types (e.g. next is invalid on an end
+    //iterator). We also need arguments for most (meta-)functions, which cannot be provided easily in the context of a concept.
+    //Therefore we ignore these (meta-)functions here.
+
+    namespace detail
+    {
+        typedef mpl::vector<forward_iterator_category,bidirectional_iterator_category,random_access_iterator_category> forward_iterator_categories;
+        typedef mpl::vector<bidirectional_iterator_category,random_access_iterator_category> bidirectional_iterator_categories;
+        typedef mpl::vector<random_access_iterator_category> random_access_iterator_categories;
+    }
+
+    auto concept ForwardIterator<class Iterator> :
+            std::CopyConstructible<Iterator>//, std::HasEqualTo<Iterator,Iterator>, std::HasNotEqualTo<Iterator,Iterator>
+    {
+        typename tag=typename Iterator::tag;
+        typename category=typename Iterator::category;
+
+        //requires std::SameType<mpl::contains<detail::forward_iterator_categories,tag>::type,mpl::true_>; segfaults in ConceptGCC!
+        typename detail_is_valid=typename mpl::contains<detail::forward_iterator_categories,category>::type;
+        requires std::SameType<detail_is_valid,mpl::true_>;
+    }
+
+    auto concept BidirectionalIterator<class Iterator> : ForwardIterator<Iterator>
+    {
+        typename detail_is_valid=typename mpl::contains<detail::bidirectional_iterator_categories,category>::type;
+        requires std::SameType<detail_is_valid,mpl::true_>;
+    }
+
+    auto concept RandomAccessIterator<class Iterator> : BidirectionalIterator<Iterator>
+    {
+        typename detail_is_valid=typename mpl::contains<detail::random_access_iterator_categories,category>::type;
+        requires std::SameType<detail_is_valid,mpl::true_>;
+    }
+
+    namespace detail
+    {
+        typedef mpl::vector<forward_sequence_category,bidirectional_sequence_category,random_access_sequence_category> forward_sequence_categories;
+        typedef mpl::vector<bidirectional_sequence_category,random_access_sequence_category> bidirectional_sequence_categories;
+        typedef mpl::vector<random_access_sequence_category> random_access_sequence_categories;
+    }
+
+    auto concept ForwardSequence<class Sequence> :
+        std::CopyConstructible<Sequence>//, std::HasEqualTo<Sequence,Sequence>, std::HasNotEqualTo<Sequence,Sequence>
+    {
+        typename tag=typename Sequence::tag;
+        typename category=typename Sequence::category;
+
+        typename detail_is_valid=typename mpl::contains<detail::forward_sequence_categories,category>::type;
+        requires std::SameType<detail_is_valid,mpl::true_>;
+    }
+
+    auto concept BidirectionalSequence<class Sequence> : ForwardSequence<Sequence>
+    {
+        typename detail_is_valid=typename mpl::contains<detail::bidirectional_sequence_categories,category>::type;
+        requires std::SameType<detail_is_valid,mpl::true_>;
+    }
+
+    auto concept RandomAccessSequence<class Sequence> : BidirectionalSequence<Sequence>
+    {
+        typename detail_is_valid=typename mpl::contains<detail::random_access_sequence_categories,category>::type;
+        requires std::SameType<detail_is_valid,mpl::true_>;
+    }
 }}}

Modified: sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp
==============================================================================
--- sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp	(original)
+++ sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -15,334 +15,334 @@
 #include <boost/mpl/bool.hpp>
 
 namespace boost{namespace fusion{namespace gsoc{
-	namespace detail
-	{
-		template<class IteratorA,class IteratorB>class is_compareable
-		{
-			static_assert(std::is_same<typename IteratorA::tag,typename IteratorB::tag>::value,"Different iterator types specified");
-			static_assert(std::is_same<typename IteratorA::sequence,typename IteratorB::sequence>::value,"Different iterator sequences");
-		};
-
-		template<class Arg>class always_false
-		{
-		public:
-			typedef boost::mpl::false_ type;
-		};
-	}
-
-	//begin
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class begin
-			{
-				static_assert(detail::always_false<Tag>::type::value, "Unsupported sequence");
-			};
-		}
-
-		template<class Sequence> class begin:
-			public impl::begin<typename Sequence::tag>::template apply<Sequence>
-		{
-		};
-	}
-	template<class Sequence> typename result_of::begin<typename std::remove_reference<Sequence>::type>::type begin(Sequence&& sequence)
-	{
-		return result_of::begin<typename std::remove_reference<Sequence>::type>::call(std::forward<Sequence>(sequence));
-	}
-	template<class Sequence> typename result_of::begin<const Sequence>::type begin(const Sequence& sequence)
-	{
-		return result_of::begin<const Sequence>::call(sequence);
-	}
-
-	//end
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class end
-			{
-				static_assert(detail::always_false<Tag>::type::value, "Unsupported sequence");
-			};
-		}
-
-		template<class Sequence>class end:
-			public impl::end<typename Sequence::tag>::template apply<Sequence>
-		{
-		};
-	}
-	template<class Sequence> typename result_of::end<typename std::remove_reference<Sequence>::type>::type end(Sequence&& sequence)
-	{
-		return result_of::end<typename std::remove_reference<Sequence>::type>::call(std::forward<Sequence>(sequence));
-	}
-	template<class Sequence> typename result_of::end<const Sequence>::type end(const Sequence& sequence)
-	{
-		return result_of::end<const Sequence>::call(sequence);
-	}
-
-	//advance_c
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class advance_c
-			{
-				static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
-			};
-		}
-
-		template<class Iterator,int Distance> class advance_c:
-			public impl::advance_c<typename Iterator::tag>::template apply<Iterator,Distance>
-		{
-		};
-	}
-	template<int Distance,class Iterator> typename result_of::advance_c<Iterator,Distance>::type advance_c(const Iterator& iterator)
-	{
-		return result_of::advance_c<Iterator,Distance>::call(iterator);
-	}
-
-	//distance
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class distance
-			{
-				static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
-			};
-		}
-
-		template<class IteratorA,class IteratorB>class distance:
-			private detail::is_compareable<IteratorA,IteratorB>,
-			public impl::distance<typename IteratorA::tag>::template apply<IteratorA,IteratorB>
-		{
-		};
-	}
-	template<class IteratorA,class IteratorB> typename result_of::distance<IteratorA,IteratorB>::type
-		distance(const IteratorA& iteratora,const IteratorB& iteratorb)
-	{
-		return typename result_of::distance<IteratorA,IteratorB>::type();
-	}
-
-	//next
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class next
-			{
-			public:
-				template<class Iterator>class apply
-				{
-				public:
-					typedef typename result_of::advance_c<Iterator,1>::type type;
-
-					static type call(const Iterator& iterator)
-					{
-						return gsoc::advance_c<1>(iterator);
-					}
-				};
-			};
-		}
-
-		template<class Iterator>class next:
-			public impl::next<typename Iterator::tag>::template apply<Iterator>
-		{
-		};
-	}
-	template<class Iterator> typename result_of::next<Iterator>::type next(const Iterator& iterator)
-	{
-		return result_of::next<Iterator>::call(iterator);
-	}
-
-	//prior
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class prior
-			{
-			public:
-				template<class Iterator>class apply
-				{
-				public:
-					typedef typename result_of::advance_c<Iterator,-1>::type type;
-
-					static type call(const Iterator& iterator)
-					{
-						return gsoc::advance_c<-1>(iterator);
-					}
-				};
-			};
-		}
-
-		template<class Iterator>class prior:
-			public impl::prior<typename Iterator::tag>::template apply<Iterator>
-		{
-		};
-	}
-	template<class Iterator> typename result_of::prior<Iterator>::type prior(const Iterator& iterator)
-	{
-		return result_of::prior<Iterator>::call(iterator);
-	}
-
-	//equal_to
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class equal_to
-			{
-			public:
-				template<class IteratorA,class IteratorB>class apply
-				{
-				public:
-					typedef mpl::bool_<std::is_same<
-						typename std::add_const<IteratorA>::type,
-						typename std::add_const<IteratorB>::type>::value> type;
-				};
-			};
-		}
-
-		template<class IteratorA,class IteratorB>class equal_to:
-			private detail::is_compareable<IteratorA,IteratorB>,
-			public impl::equal_to<typename IteratorA::tag>::template apply<IteratorA,IteratorB>
-		{
-		};
-	}
-	template<class IteratorA,class IteratorB> typename result_of::equal_to<IteratorA,IteratorB>::type
-		equal_to(const IteratorA& iteratora,const IteratorB& iteratorb)
-	{
-		return typename result_of::equal_to<IteratorA,IteratorB>::type();
-	}
-
-	//size
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class size
-			{
-			public:
-				template<class Sequence>class apply:
-					public result_of::distance<typename result_of::begin<Sequence>::type,typename result_of::end<Sequence>::type>
-				{
-				};
-			};
-		}
-
-		template<class Sequence>class size :
-			public impl::size<typename Sequence::tag>::template apply<Sequence>
-		{
-		};
-	}
-	template<class Sequence> typename result_of::size<Sequence>::type size(const Sequence&)
-	{
-		return typename result_of::size<Sequence>::type();
-	}
-
-	//empty
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class empty
-			{
-			public:
-				template<class Sequence> class apply
-				{
-				public:
-					typedef mpl::bool_<result_of::equal_to<
-						typename result_of::begin<Sequence>::type,
-						typename result_of::end<Sequence>::type>::type::value> type;
-				};
-			};
-		}
-
-		template<class Sequence>class empty:
-			public impl::empty<typename Sequence::tag>::template apply<Sequence>
-		{
-		};
-	}
-	template<class Sequence> typename result_of::empty<Sequence>::type empty(const Sequence&)
-	{
-		return typename result_of::empty<Sequence>::type();
-	}
-
-	//value_of
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class value_of
-			{
-				static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
-			};
-		}
-
-		template<class Iterator>class value_of:
-			public impl::value_of<typename Iterator::tag>::template apply<Iterator>
-		{
-		};
-	}
-
-	//deref
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class deref
-			{
-				static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
-			};
-		}
-
-		template<class Iterator>class deref:
-			public impl::deref<typename Iterator::tag>::template apply<Iterator>
-		{
-		};
-	}
-	template<class Iterator>typename result_of::deref<Iterator>::type deref(const Iterator& iterator)
-	{
-		return result_of::deref<Iterator>::call(iterator);
-	}
-
-	//at_c
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<class Tag>class at_c
-			{
-			public:
-				template<class Container,std::size_t Index>class apply
-				{
-				public:
-					typedef typename result_of::deref<
-						typename result_of::advance_c<typename result_of::begin<Container>::type,Index>::type>::type type;
-
-					static type call(Container& container)
-					{
-						return gsoc::deref(gsoc::advance_c<Index>(gsoc::begin(container)));
-					}
-				};
-			};
-		}
-
-		template<class Container,std::size_t Index>class at_c:
-			public impl::at_c<typename Container::tag>::template apply<Container,Index>
-		{
-		};
-	}
-
-	template<std::size_t Index,class Container>typename result_of::at_c<const Container,Index>::type at_c(const Container& container)
-	{
-		return result_of::at_c<const Container,Index>::call(container);
-	}
-
-	template<std::size_t Index,class Container>typename result_of::at_c<Container,Index>::type at_c(Container& container)
-	{
-		return result_of::at_c<Container,Index>::call(container);
-	}
+    namespace detail
+    {
+        template<class IteratorA,class IteratorB>class is_compareable
+        {
+            static_assert(std::is_same<typename IteratorA::tag,typename IteratorB::tag>::value,"Different iterator types specified");
+            static_assert(std::is_same<typename IteratorA::sequence,typename IteratorB::sequence>::value,"Different iterator sequences");
+        };
+
+        template<class Arg>class always_false
+        {
+        public:
+            typedef boost::mpl::false_ type;
+        };
+    }
+
+    //begin
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class begin
+            {
+                static_assert(detail::always_false<Tag>::type::value, "Unsupported sequence");
+            };
+        }
+
+        template<class Sequence> class begin:
+            public impl::begin<typename Sequence::tag>::template apply<Sequence>
+        {
+        };
+    }
+    template<class Sequence> typename result_of::begin<typename std::remove_reference<Sequence>::type>::type begin(Sequence&& sequence)
+    {
+        return result_of::begin<typename std::remove_reference<Sequence>::type>::call(std::forward<Sequence>(sequence));
+    }
+    template<class Sequence> typename result_of::begin<const Sequence>::type begin(const Sequence& sequence)
+    {
+        return result_of::begin<const Sequence>::call(sequence);
+    }
+
+    //end
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class end
+            {
+                static_assert(detail::always_false<Tag>::type::value, "Unsupported sequence");
+            };
+        }
+
+        template<class Sequence>class end:
+            public impl::end<typename Sequence::tag>::template apply<Sequence>
+        {
+        };
+    }
+    template<class Sequence> typename result_of::end<typename std::remove_reference<Sequence>::type>::type end(Sequence&& sequence)
+    {
+        return result_of::end<typename std::remove_reference<Sequence>::type>::call(std::forward<Sequence>(sequence));
+    }
+    template<class Sequence> typename result_of::end<const Sequence>::type end(const Sequence& sequence)
+    {
+        return result_of::end<const Sequence>::call(sequence);
+    }
+
+    //advance_c
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class advance_c
+            {
+                static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
+            };
+        }
+
+        template<class Iterator,int Distance> class advance_c:
+            public impl::advance_c<typename Iterator::tag>::template apply<Iterator,Distance>
+        {
+        };
+    }
+    template<int Distance,class Iterator> typename result_of::advance_c<Iterator,Distance>::type advance_c(const Iterator& iterator)
+    {
+        return result_of::advance_c<Iterator,Distance>::call(iterator);
+    }
+
+    //distance
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class distance
+            {
+                static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
+            };
+        }
+
+        template<class IteratorA,class IteratorB>class distance:
+            private detail::is_compareable<IteratorA,IteratorB>,
+            public impl::distance<typename IteratorA::tag>::template apply<IteratorA,IteratorB>
+        {
+        };
+    }
+    template<class IteratorA,class IteratorB> typename result_of::distance<IteratorA,IteratorB>::type
+        distance(const IteratorA& iteratora,const IteratorB& iteratorb)
+    {
+        return typename result_of::distance<IteratorA,IteratorB>::type();
+    }
+
+    //next
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class next
+            {
+            public:
+                template<class Iterator>class apply
+                {
+                public:
+                    typedef typename result_of::advance_c<Iterator,1>::type type;
+
+                    static type call(const Iterator& iterator)
+                    {
+                        return gsoc::advance_c<1>(iterator);
+                    }
+                };
+            };
+        }
+
+        template<class Iterator>class next:
+            public impl::next<typename Iterator::tag>::template apply<Iterator>
+        {
+        };
+    }
+    template<class Iterator> typename result_of::next<Iterator>::type next(const Iterator& iterator)
+    {
+        return result_of::next<Iterator>::call(iterator);
+    }
+
+    //prior
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class prior
+            {
+            public:
+                template<class Iterator>class apply
+                {
+                public:
+                    typedef typename result_of::advance_c<Iterator,-1>::type type;
+
+                    static type call(const Iterator& iterator)
+                    {
+                        return gsoc::advance_c<-1>(iterator);
+                    }
+                };
+            };
+        }
+
+        template<class Iterator>class prior:
+            public impl::prior<typename Iterator::tag>::template apply<Iterator>
+        {
+        };
+    }
+    template<class Iterator> typename result_of::prior<Iterator>::type prior(const Iterator& iterator)
+    {
+        return result_of::prior<Iterator>::call(iterator);
+    }
+
+    //equal_to
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class equal_to
+            {
+            public:
+                template<class IteratorA,class IteratorB>class apply
+                {
+                public:
+                    typedef mpl::bool_<std::is_same<
+                        typename std::add_const<IteratorA>::type,
+                        typename std::add_const<IteratorB>::type>::value> type;
+                };
+            };
+        }
+
+        template<class IteratorA,class IteratorB>class equal_to:
+            private detail::is_compareable<IteratorA,IteratorB>,
+            public impl::equal_to<typename IteratorA::tag>::template apply<IteratorA,IteratorB>
+        {
+        };
+    }
+    template<class IteratorA,class IteratorB> typename result_of::equal_to<IteratorA,IteratorB>::type
+        equal_to(const IteratorA& iteratora,const IteratorB& iteratorb)
+    {
+        return typename result_of::equal_to<IteratorA,IteratorB>::type();
+    }
+
+    //size
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class size
+            {
+            public:
+                template<class Sequence>class apply:
+                    public result_of::distance<typename result_of::begin<Sequence>::type,typename result_of::end<Sequence>::type>
+                {
+                };
+            };
+        }
+
+        template<class Sequence>class size :
+            public impl::size<typename Sequence::tag>::template apply<Sequence>
+        {
+        };
+    }
+    template<class Sequence> typename result_of::size<Sequence>::type size(const Sequence&)
+    {
+        return typename result_of::size<Sequence>::type();
+    }
+
+    //empty
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class empty
+            {
+            public:
+                template<class Sequence> class apply
+                {
+                public:
+                    typedef mpl::bool_<result_of::equal_to<
+                        typename result_of::begin<Sequence>::type,
+                        typename result_of::end<Sequence>::type>::type::value> type;
+                };
+            };
+        }
+
+        template<class Sequence>class empty:
+            public impl::empty<typename Sequence::tag>::template apply<Sequence>
+        {
+        };
+    }
+    template<class Sequence> typename result_of::empty<Sequence>::type empty(const Sequence&)
+    {
+        return typename result_of::empty<Sequence>::type();
+    }
+
+    //value_of
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class value_of
+            {
+                static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
+            };
+        }
+
+        template<class Iterator>class value_of:
+            public impl::value_of<typename Iterator::tag>::template apply<Iterator>
+        {
+        };
+    }
+
+    //deref
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class deref
+            {
+                static_assert(detail::always_false<Tag>::type::value, "Unsupported iterator");
+            };
+        }
+
+        template<class Iterator>class deref:
+            public impl::deref<typename Iterator::tag>::template apply<Iterator>
+        {
+        };
+    }
+    template<class Iterator>typename result_of::deref<Iterator>::type deref(const Iterator& iterator)
+    {
+        return result_of::deref<Iterator>::call(iterator);
+    }
+
+    //at_c
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<class Tag>class at_c
+            {
+            public:
+                template<class Container,std::size_t Index>class apply
+                {
+                public:
+                    typedef typename result_of::deref<
+                        typename result_of::advance_c<typename result_of::begin<Container>::type,Index>::type>::type type;
+
+                    static type call(Container& container)
+                    {
+                        return gsoc::deref(gsoc::advance_c<Index>(gsoc::begin(container)));
+                    }
+                };
+            };
+        }
+
+        template<class Container,std::size_t Index>class at_c:
+            public impl::at_c<typename Container::tag>::template apply<Container,Index>
+        {
+        };
+    }
+
+    template<std::size_t Index,class Container>typename result_of::at_c<const Container,Index>::type at_c(const Container& container)
+    {
+        return result_of::at_c<const Container,Index>::call(container);
+    }
+
+    template<std::size_t Index,class Container>typename result_of::at_c<Container,Index>::type at_c(Container& container)
+    {
+        return result_of::at_c<Container,Index>::call(container);
+    }
 }}}
 

Modified: sandbox/SOC/2009/fusion/mini-fusion/test.cpp
==============================================================================
--- sandbox/SOC/2009/fusion/mini-fusion/test.cpp	(original)
+++ sandbox/SOC/2009/fusion/mini-fusion/test.cpp	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -14,134 +14,134 @@
 class copyable
 {
 public:
-	copyable()
-	{
-	}
-	copyable(const copyable&)
-	{
-	}
-	copyable& operator=(const copyable&)
-	{
-		return *this;
-	}
+    copyable()
+    {
+    }
+    copyable(const copyable&)
+    {
+    }
+    copyable& operator=(const copyable&)
+    {
+        return *this;
+    }
 };
 
 class moveable
 {
 private:
-	moveable(const moveable&);
+    moveable(const moveable&);
 
 public:
-	moveable()
-	{
-	}
-	moveable(moveable&&)
-	{
-	}
-	moveable& operator=(moveable&&)
-	{
-		return *this;
-	}
+    moveable()
+    {
+    }
+    moveable(moveable&&)
+    {
+    }
+    moveable& operator=(moveable&&)
+    {
+        return *this;
+    }
 };
 
 int main()
 {
-	namespace gsoc=boost::fusion::gsoc;
+    namespace gsoc=boost::fusion::gsoc;
 
-	{
-		typedef gsoc::vector<> at;
+    {
+        typedef gsoc::vector<> at;
 
-		{
-			using namespace gsoc::result_of;
-			static_assert(equal_to<advance_c<begin<at>::type,0>::type,end<at>::type>::type::value,"");
-			static_assert(!distance<begin<at>::type,end<at>::type>::type::value,"");
-			static_assert(!size<at>::type::value,"");
-			static_assert(empty<at>::type::value,"");
-		}
-
-		{
-			at a;
-
-			using namespace gsoc;
-			assert(equal_to(advance_c<0>(begin(a)),end(a)));
-			assert(!distance(begin(a),end(a)));
-			assert(!size(a));
-			assert(empty(a));
-		}
-	}
-
-	{
-		typedef gsoc::vector<long long,float,char> bt;
-
-		{
-			using namespace gsoc::result_of;
-			static_assert(equal_to<advance_c<begin<bt>::type,3>::type,end<bt>::type>::type::value,"");
-			static_assert(distance<begin<bt>::type,end<bt>::type>::type::value==3,"");
-			static_assert(distance<next<begin<bt>::type>::type,prior<end<bt>::type>::type>::type::value==1,"");
-			static_assert(size<bt>::type::value==3,"");
-			static_assert(!empty<bt>::type::value,"");
-
-			static_assert(std::is_same<value_of<begin<bt>::type>::type,long long>::value,"");
-		}
-
-		{
-			bt b(0xDEADBEEF,1337.0f,42);
-
-			using namespace gsoc;
-			assert(equal_to(advance_c<3>(begin(b)),end(b)));
-			assert(distance(begin(b),end(b))==3);
-			assert(distance(next(begin(b)),prior(end(b)))==1);
-			assert(size(b)==3);
-			assert(!empty(b));
-
-			assert(deref(begin(b))==0xDEADBEEF);
-			at_c<0>(b)=0xBEEFDEEF;
-			assert(at_c<0>(b)==0xBEEFDEEF);
-		}
-
-		{
-			bt b(0xDEADBEEF,1337.0f,42);
-
-			using namespace gsoc;
-			assert(deref(begin(b))==0xDEADBEEF);
-			at_c<0>(b)=0xBEEFDEEF;
-			assert(at_c<0>(b)==0xBEEFDEEF);
-		}
-	}
-
-	{
-		using namespace gsoc;
-		//equal_to(begin(vector<long long>()),begin(vector<int>()));
-		assert(equal_to(begin(vector<long long>()),begin(vector<long long>()))==true);
-	}
-
-	{
-		using namespace gsoc::result_of;
-
-		typedef const gsoc::vector<float> f;
-		static_assert(std::is_same<deref<begin<f>::type>::type,const float&>::value,"");
-		static_assert(std::is_same<deref<advance_c<begin<f>::type,0>::type>::type,const float&>::value,"");
-
-	}
-
-	{
-		gsoc::vector<moveable,moveable> c;
-		gsoc::vector<moveable,moveable> d;
-		c=std::move(d);
-	}
-
-	{
-		gsoc::vector<copyable,copyable> c;
-		gsoc::vector<copyable,copyable> d;
-		c=d;
-		c=std::move(d);
-	}
-
-	{
-		gsoc::vector<moveable,copyable> c;
-		gsoc::vector<moveable,copyable> d;
-		c=std::move(d);
-	}
+        {
+            using namespace gsoc::result_of;
+            static_assert(equal_to<advance_c<begin<at>::type,0>::type,end<at>::type>::type::value,"");
+            static_assert(!distance<begin<at>::type,end<at>::type>::type::value,"");
+            static_assert(!size<at>::type::value,"");
+            static_assert(empty<at>::type::value,"");
+        }
+
+        {
+            at a;
+
+            using namespace gsoc;
+            assert(equal_to(advance_c<0>(begin(a)),end(a)));
+            assert(!distance(begin(a),end(a)));
+            assert(!size(a));
+            assert(empty(a));
+        }
+    }
+
+    {
+        typedef gsoc::vector<long long,float,char> bt;
+
+        {
+            using namespace gsoc::result_of;
+            static_assert(equal_to<advance_c<begin<bt>::type,3>::type,end<bt>::type>::type::value,"");
+            static_assert(distance<begin<bt>::type,end<bt>::type>::type::value==3,"");
+            static_assert(distance<next<begin<bt>::type>::type,prior<end<bt>::type>::type>::type::value==1,"");
+            static_assert(size<bt>::type::value==3,"");
+            static_assert(!empty<bt>::type::value,"");
+
+            static_assert(std::is_same<value_of<begin<bt>::type>::type,long long>::value,"");
+        }
+
+        {
+            bt b(0xDEADBEEF,1337.0f,42);
+
+            using namespace gsoc;
+            assert(equal_to(advance_c<3>(begin(b)),end(b)));
+            assert(distance(begin(b),end(b))==3);
+            assert(distance(next(begin(b)),prior(end(b)))==1);
+            assert(size(b)==3);
+            assert(!empty(b));
+
+            assert(deref(begin(b))==0xDEADBEEF);
+            at_c<0>(b)=0xBEEFDEEF;
+            assert(at_c<0>(b)==0xBEEFDEEF);
+        }
+
+        {
+            bt b(0xDEADBEEF,1337.0f,42);
+
+            using namespace gsoc;
+            assert(deref(begin(b))==0xDEADBEEF);
+            at_c<0>(b)=0xBEEFDEEF;
+            assert(at_c<0>(b)==0xBEEFDEEF);
+        }
+    }
+
+    {
+        using namespace gsoc;
+        //equal_to(begin(vector<long long>()),begin(vector<int>()));
+        assert(equal_to(begin(vector<long long>()),begin(vector<long long>()))==true);
+    }
+
+    {
+        using namespace gsoc::result_of;
+
+        typedef const gsoc::vector<float> f;
+        static_assert(std::is_same<deref<begin<f>::type>::type,const float&>::value,"");
+        static_assert(std::is_same<deref<advance_c<begin<f>::type,0>::type>::type,const float&>::value,"");
+
+    }
+
+    {
+        gsoc::vector<moveable,moveable> c;
+        gsoc::vector<moveable,moveable> d;
+        c=std::move(d);
+    }
+
+    {
+        gsoc::vector<copyable,copyable> c;
+        gsoc::vector<copyable,copyable> d;
+        c=d;
+        c=std::move(d);
+    }
+
+    {
+        gsoc::vector<moveable,copyable> c;
+        gsoc::vector<moveable,copyable> d;
+        c=std::move(d);
+    }
 
-	return 0;
+    return 0;
 }

Modified: sandbox/SOC/2009/fusion/mini-fusion/vector.hpp
==============================================================================
--- sandbox/SOC/2009/fusion/mini-fusion/vector.hpp	(original)
+++ sandbox/SOC/2009/fusion/mini-fusion/vector.hpp	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -16,367 +16,367 @@
 #include <boost/mpl/identity.hpp>
 
 namespace boost{namespace fusion{namespace gsoc{
-	class vector_tag;
+    class vector_tag;
 
-	namespace detail
-	{
-		class vector_iterator_tag;
-		template<class Vector,std::size_t Index> class vector_iterator
-		{
-			template<class,class>friend class is_compareable;
-			friend class result_of::impl::end<vector_tag>;
-			friend class result_of::impl::begin<vector_tag>;
-			friend class result_of::impl::advance_c<vector_iterator_tag>;
-			friend class result_of::impl::distance<vector_iterator_tag>;
-			friend class result_of::impl::value_of<vector_iterator_tag>;
-			friend class result_of::impl::deref<vector_iterator_tag>;
-
-		public:
-			typedef random_access_iterator_category category;
-			typedef vector_iterator_tag tag;
-			typedef mpl::bool_<std::is_const<Vector>::value> is_const;
-
-		private:
-			typedef Vector sequence;
-			typedef mpl::size_t<Index> index;
-
-			Vector& _vector;
-
-			vector_iterator(Vector& vector):
-				_vector(vector)
-			{
-			}
-
-		public:
-			vector_iterator(const vector_iterator& other_iterator):
-				_vector(other_iterator._vector)
-			{
-			}
-
-			vector_iterator& operator=(const vector_iterator& other_iterator)
-			{
-				_vector=other_iterator._vector;
-				return *this;
-			}
-		};
-
-		template<class... Elements> class vector_impl;
-		template<> class vector_impl<>{};
-
-		template<class Head,class...Other>class vector_impl<Head,Other...> :
-			public vector_impl<Other...>
-		{
-		public:
-			friend class result_of::impl::deref<detail::vector_iterator_tag>;
-
-			typedef vector_impl<Other...> base;
-			typedef Head head_type;
-
-		private:
-			Head _element;
-
-		public:
-			vector_impl()
-			{
-			}
-
-			vector_impl(const vector_impl& other_impl):
-				base(static_cast<const base&>(other_impl)),
-				_element(other_impl._element)
-			{
-			}
-
-			vector_impl(vector_impl&& other_impl):
-				base(std::move(static_cast<base&>(other_impl))),
-				_element(std::move(other_impl._element))
-			{
-			}
-
-			template<class OtherHead,class... OtherElements>vector_impl(const OtherHead& other_head,const OtherElements&... other_elements):
-				base(other_elements...),
-				_element(other_head)
-			{
-			}
-
-			template<class OtherHead,class... OtherElements>vector_impl(OtherHead&& other_head,OtherElements&&... other_elements):
-				base(std::forward<OtherElements>(other_elements)...),
-				_element(std::forward<OtherHead>(other_head))
-			{
-			}
-
-			template<class OtherHead,class... OtherElements>vector_impl(const vector_impl<OtherHead,OtherElements...>& other_impl):
-				base(static_cast<const typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl)),
-				_element(other_impl._element)
-			{
-			}
-
-			template<class OtherHead,class... OtherElements>vector_impl(vector_impl<OtherHead,OtherElements...>&& other_impl):
-				base(std::move(static_cast<typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl))),
-				_element(std::move(other_impl._element))
-			{
-			}
-
-			void operator=(const vector_impl& other_impl)
-			{
-				_element=other_impl._element;
-				static_cast<base&>(*this)=static_cast<const base&>(other_impl);
-			}
-
-			void operator=(vector_impl&& other_impl)
-			{
-				_element=std::move(other_impl._element);
-				static_cast<base&>(*this)=std::move(static_cast<base&>(other_impl));
-			}
-
-			template<class OtherHead,class... OtherElements>void operator=(const vector_impl<OtherHead,OtherElements...>& other_impl)
-			{
-				_element=other_impl._element;
-				static_cast<base&>(*this)=static_cast<const typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl);
-			}
-
-			template<class OtherHead,class... OtherElements>void operator=(vector_impl<OtherHead,OtherElements...>&& other_impl)
-			{
-				_element=std::move(other_impl._element);
-				static_cast<base&>(*this)=std::move(static_cast<typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl));
-			}
-		};
-	}
-
-	template<class... Elements>class vector:
-		private detail::vector_impl<Elements...>
-	{
-		friend class result_of::impl::end<vector_tag>;
-		friend class result_of::impl::begin<vector_tag>;
-		friend class result_of::impl::value_of<detail::vector_iterator_tag>;
-		friend class result_of::impl::deref<detail::vector_iterator_tag>;
-
-	private:
-		typedef detail::vector_impl<Elements...> base;
-		typedef mpl::size_t<sizeof...(Elements)> num_elements;
-
-	public:
-		typedef random_access_sequence_category category;
-		typedef vector_tag tag;
-
-		vector()
-		{
-		}
-
-		vector(const vector& other_vector):
-			base(other_vector)
-		{
-		}
-
-		vector(vector&& other_vector):
-			base(std::move(other_vector))
-		{
-		}
-
-		template<class... OtherElements> vector(const vector<OtherElements...>& other_vector):
-			base(other_vector)
-		{
-		}
-
-		template<class... OtherElements> vector(vector<OtherElements...>&& other_vector):
-			base(std::move(other_vector))
-		{
-		}
-
-		template<class... OtherElements> explicit vector(const OtherElements&... other_elements):
-			base(std::forward<OtherElements>(other_elements)...)
-		{
-		}
-
-		template<class... OtherElements> explicit vector(OtherElements&&... other_elements):
-			base(std::forward<OtherElements>(other_elements)...)
-		{
-		}
-
-		/*template<class OtherSequence> vector(OtherSequence&& other_sequence)
-		{
-		}
-
-		template<class OtherSequence> vector(const OtherSequence& other_sequence)
-		{
-		}*/
-
-		vector& operator=(const vector& other_vector)
-		{
-			static_cast<base&>(*this)=other_vector;
-			return *this;
-		}
-
-		vector& operator=(vector&& other_vector)
-		{
-			static_cast<base&>(*this)=std::move(other_vector);
-			return *this;
-		}
-	};
-
-	//begin
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<>class begin<vector_tag>
-			{
-			public:
-				template<class Vector>class apply
-				{
-				public:
-					typedef gsoc::detail::vector_iterator<Vector,0> type;
-
-					static type call(Vector&& vector)
-					{
-						return type(vector);
-					}
-
-					static type call(Vector& vector)
-					{
-						return type(vector);
-					}
-				};
-			};
-		}
-	}
-
-	//end
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<>class end<vector_tag>
-			{
-			public:
-				template<class Vector> class apply
-				{
-				public:
-					typedef gsoc::detail::vector_iterator<Vector,Vector::num_elements::value> type;
-
-					static type call(Vector&& vector)
-					{
-						return type(vector);
-					}
-
-					static type call(Vector& vector)
-					{
-						return type(vector);
-					}
-				};
-			};
-		}
-	}
-
-	//advance_c
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<>class advance_c<gsoc::detail::vector_iterator_tag>
-			{
-			public:
-				template<class Iterator,int Distance>class apply
-				{
-				public:
-					typedef gsoc::detail::vector_iterator<typename Iterator::sequence,Iterator::index::value+Distance> type;
-
-					static type call(const Iterator& iterator)
-					{
-						return type(iterator._vector);
-					}
-				};
-			};
-		}
-	}
-
-	//distance
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<>class distance<gsoc::detail::vector_iterator_tag>
-			{
-			public:
-				template<class IteratorA,class IteratorB>class apply
-				{
-				public:
-					typedef mpl::size_t<IteratorB::index::value-IteratorA::index::value> type;
-				};
-			};
-		}
-	}
-
-	//value_of
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<>class value_of<gsoc::detail::vector_iterator_tag>
-			{
-			public:
-				template<class Iterator>class apply
-				{
-				private:
-					template<class VectorImpl,std::size_t Counter>class impl
-					{
-					public:
-						typedef typename mpl::eval_if_c<!Counter,
-							mpl::identity<typename VectorImpl::head_type>,
-							impl<typename VectorImpl::base,Counter-1> >::type type;
-					};
-
-				public:
-					typedef typename impl<typename Iterator::sequence::base,Iterator::index::value>::type type;
-				};
-			};
-		}
-	}
-
-	//deref
-	namespace result_of
-	{
-		namespace impl
-		{
-			template<>class deref<gsoc::detail::vector_iterator_tag>
-			{
-			public:
-				template<class Iterator>class apply
-				{
-				private:
-					typedef typename result_of::value_of<Iterator>::type value_type;
-				public:
-					typedef typename std::add_reference<
-						typename std::conditional<Iterator::is_const::value,typename std::add_const<value_type>::type,value_type>::type
-						>::type type;
-
-				private:
-					template<std::size_t Index,class VectorImpl>static typename std::enable_if<!Index,type>::type impl(VectorImpl& impl)
-					{
-						return impl._element;
-					}
-
-					template<std::size_t Index,class VectorImpl>static typename std::enable_if<Index,type>::type impl(VectorImpl& impl)
-					{
-						return impl<Index-1>(static_cast<typename VectorImpl::base&>(impl));
-					}
-
-					template<std::size_t Index,class VectorImpl>static typename std::enable_if<!Index,type>::type impl(const VectorImpl& impl)
-					{
-						return impl._element;
-					}
-
-					template<std::size_t Index,class VectorImpl>static typename std::enable_if<Index,type>::type impl(const VectorImpl& impl)
-					{
-						return impl<Index-1>(static_cast<const typename VectorImpl::base&>(impl));
-					}
-
-				public:
-					static type call(const Iterator& iterator)
-					{
-						return impl<Iterator::index::value>(iterator._vector);
-					}
-				};
-			};
-		}
-	}
+    namespace detail
+    {
+        class vector_iterator_tag;
+        template<class Vector,std::size_t Index> class vector_iterator
+        {
+            template<class,class>friend class is_compareable;
+            friend class result_of::impl::end<vector_tag>;
+            friend class result_of::impl::begin<vector_tag>;
+            friend class result_of::impl::advance_c<vector_iterator_tag>;
+            friend class result_of::impl::distance<vector_iterator_tag>;
+            friend class result_of::impl::value_of<vector_iterator_tag>;
+            friend class result_of::impl::deref<vector_iterator_tag>;
+
+        public:
+            typedef random_access_iterator_category category;
+            typedef vector_iterator_tag tag;
+            typedef mpl::bool_<std::is_const<Vector>::value> is_const;
+
+        private:
+            typedef Vector sequence;
+            typedef mpl::size_t<Index> index;
+
+            Vector& _vector;
+
+            vector_iterator(Vector& vector):
+                _vector(vector)
+            {
+            }
+
+        public:
+            vector_iterator(const vector_iterator& other_iterator):
+                _vector(other_iterator._vector)
+            {
+            }
+
+            vector_iterator& operator=(const vector_iterator& other_iterator)
+            {
+                _vector=other_iterator._vector;
+                return *this;
+            }
+        };
+
+        template<class... Elements> class vector_impl;
+        template<> class vector_impl<>{};
+
+        template<class Head,class...Other>class vector_impl<Head,Other...> :
+            public vector_impl<Other...>
+        {
+        public:
+            friend class result_of::impl::deref<detail::vector_iterator_tag>;
+
+            typedef vector_impl<Other...> base;
+            typedef Head head_type;
+
+        private:
+            Head _element;
+
+        public:
+            vector_impl()
+            {
+            }
+
+            vector_impl(const vector_impl& other_impl):
+                base(static_cast<const base&>(other_impl)),
+                _element(other_impl._element)
+            {
+            }
+
+            vector_impl(vector_impl&& other_impl):
+                base(std::move(static_cast<base&>(other_impl))),
+                _element(std::move(other_impl._element))
+            {
+            }
+
+            template<class OtherHead,class... OtherElements>vector_impl(const OtherHead& other_head,const OtherElements&... other_elements):
+                base(other_elements...),
+                _element(other_head)
+            {
+            }
+
+            template<class OtherHead,class... OtherElements>vector_impl(OtherHead&& other_head,OtherElements&&... other_elements):
+                base(std::forward<OtherElements>(other_elements)...),
+                _element(std::forward<OtherHead>(other_head))
+            {
+            }
+
+            template<class OtherHead,class... OtherElements>vector_impl(const vector_impl<OtherHead,OtherElements...>& other_impl):
+                base(static_cast<const typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl)),
+                _element(other_impl._element)
+            {
+            }
+
+            template<class OtherHead,class... OtherElements>vector_impl(vector_impl<OtherHead,OtherElements...>&& other_impl):
+                base(std::move(static_cast<typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl))),
+                _element(std::move(other_impl._element))
+            {
+            }
+
+            void operator=(const vector_impl& other_impl)
+            {
+                _element=other_impl._element;
+                static_cast<base&>(*this)=static_cast<const base&>(other_impl);
+            }
+
+            void operator=(vector_impl&& other_impl)
+            {
+                _element=std::move(other_impl._element);
+                static_cast<base&>(*this)=std::move(static_cast<base&>(other_impl));
+            }
+
+            template<class OtherHead,class... OtherElements>void operator=(const vector_impl<OtherHead,OtherElements...>& other_impl)
+            {
+                _element=other_impl._element;
+                static_cast<base&>(*this)=static_cast<const typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl);
+            }
+
+            template<class OtherHead,class... OtherElements>void operator=(vector_impl<OtherHead,OtherElements...>&& other_impl)
+            {
+                _element=std::move(other_impl._element);
+                static_cast<base&>(*this)=std::move(static_cast<typename vector_impl<OtherHead,OtherElements...>::base&>(other_impl));
+            }
+        };
+    }
+
+    template<class... Elements>class vector:
+        private detail::vector_impl<Elements...>
+    {
+        friend class result_of::impl::end<vector_tag>;
+        friend class result_of::impl::begin<vector_tag>;
+        friend class result_of::impl::value_of<detail::vector_iterator_tag>;
+        friend class result_of::impl::deref<detail::vector_iterator_tag>;
+
+    private:
+        typedef detail::vector_impl<Elements...> base;
+        typedef mpl::size_t<sizeof...(Elements)> num_elements;
+
+    public:
+        typedef random_access_sequence_category category;
+        typedef vector_tag tag;
+
+        vector()
+        {
+        }
+
+        vector(const vector& other_vector):
+            base(other_vector)
+        {
+        }
+
+        vector(vector&& other_vector):
+            base(std::move(other_vector))
+        {
+        }
+
+        template<class... OtherElements> vector(const vector<OtherElements...>& other_vector):
+            base(other_vector)
+        {
+        }
+
+        template<class... OtherElements> vector(vector<OtherElements...>&& other_vector):
+            base(std::move(other_vector))
+        {
+        }
+
+        template<class... OtherElements> explicit vector(const OtherElements&... other_elements):
+            base(std::forward<OtherElements>(other_elements)...)
+        {
+        }
+
+        template<class... OtherElements> explicit vector(OtherElements&&... other_elements):
+            base(std::forward<OtherElements>(other_elements)...)
+        {
+        }
+
+        /*template<class OtherSequence> vector(OtherSequence&& other_sequence)
+        {
+        }
+
+        template<class OtherSequence> vector(const OtherSequence& other_sequence)
+        {
+        }*/
+
+        vector& operator=(const vector& other_vector)
+        {
+            static_cast<base&>(*this)=other_vector;
+            return *this;
+        }
+
+        vector& operator=(vector&& other_vector)
+        {
+            static_cast<base&>(*this)=std::move(other_vector);
+            return *this;
+        }
+    };
+
+    //begin
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<>class begin<vector_tag>
+            {
+            public:
+                template<class Vector>class apply
+                {
+                public:
+                    typedef gsoc::detail::vector_iterator<Vector,0> type;
+
+                    static type call(Vector&& vector)
+                    {
+                        return type(vector);
+                    }
+
+                    static type call(Vector& vector)
+                    {
+                        return type(vector);
+                    }
+                };
+            };
+        }
+    }
+
+    //end
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<>class end<vector_tag>
+            {
+            public:
+                template<class Vector> class apply
+                {
+                public:
+                    typedef gsoc::detail::vector_iterator<Vector,Vector::num_elements::value> type;
+
+                    static type call(Vector&& vector)
+                    {
+                        return type(vector);
+                    }
+
+                    static type call(Vector& vector)
+                    {
+                        return type(vector);
+                    }
+                };
+            };
+        }
+    }
+
+    //advance_c
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<>class advance_c<gsoc::detail::vector_iterator_tag>
+            {
+            public:
+                template<class Iterator,int Distance>class apply
+                {
+                public:
+                    typedef gsoc::detail::vector_iterator<typename Iterator::sequence,Iterator::index::value+Distance> type;
+
+                    static type call(const Iterator& iterator)
+                    {
+                        return type(iterator._vector);
+                    }
+                };
+            };
+        }
+    }
+
+    //distance
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<>class distance<gsoc::detail::vector_iterator_tag>
+            {
+            public:
+                template<class IteratorA,class IteratorB>class apply
+                {
+                public:
+                    typedef mpl::size_t<IteratorB::index::value-IteratorA::index::value> type;
+                };
+            };
+        }
+    }
+
+    //value_of
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<>class value_of<gsoc::detail::vector_iterator_tag>
+            {
+            public:
+                template<class Iterator>class apply
+                {
+                private:
+                    template<class VectorImpl,std::size_t Counter>class impl
+                    {
+                    public:
+                        typedef typename mpl::eval_if_c<!Counter,
+                            mpl::identity<typename VectorImpl::head_type>,
+                            impl<typename VectorImpl::base,Counter-1> >::type type;
+                    };
+
+                public:
+                    typedef typename impl<typename Iterator::sequence::base,Iterator::index::value>::type type;
+                };
+            };
+        }
+    }
+
+    //deref
+    namespace result_of
+    {
+        namespace impl
+        {
+            template<>class deref<gsoc::detail::vector_iterator_tag>
+            {
+            public:
+                template<class Iterator>class apply
+                {
+                private:
+                    typedef typename result_of::value_of<Iterator>::type value_type;
+                public:
+                    typedef typename std::add_reference<
+                        typename std::conditional<Iterator::is_const::value,typename std::add_const<value_type>::type,value_type>::type
+                        >::type type;
+
+                private:
+                    template<std::size_t Index,class VectorImpl>static typename std::enable_if<!Index,type>::type impl(VectorImpl& impl)
+                    {
+                        return impl._element;
+                    }
+
+                    template<std::size_t Index,class VectorImpl>static typename std::enable_if<Index,type>::type impl(VectorImpl& impl)
+                    {
+                        return impl<Index-1>(static_cast<typename VectorImpl::base&>(impl));
+                    }
+
+                    template<std::size_t Index,class VectorImpl>static typename std::enable_if<!Index,type>::type impl(const VectorImpl& impl)
+                    {
+                        return impl._element;
+                    }
+
+                    template<std::size_t Index,class VectorImpl>static typename std::enable_if<Index,type>::type impl(const VectorImpl& impl)
+                    {
+                        return impl<Index-1>(static_cast<const typename VectorImpl::base&>(impl));
+                    }
+
+                public:
+                    static type call(const Iterator& iterator)
+                    {
+                        return impl<Iterator::index::value>(iterator._vector);
+                    }
+                };
+            };
+        }
+    }
 }}}

Modified: sandbox/SOC/2009/fusion/workaround/conceptgcc/utility
==============================================================================
--- sandbox/SOC/2009/fusion/workaround/conceptgcc/utility	(original)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/utility	2009-04-27 12:05:05 EDT (Mon, 27 Apr 2009)
@@ -12,51 +12,51 @@
 
 namespace std
 {
-	template<bool, class>class enable_if
-	{
-	};
-
-	template<class Type>class enable_if<true, Type>
-	{
-	public:
-		typedef Type type;
-	};
-
-	template<bool, class TrueType, class>class conditional
-	{
-	public:
-		typedef TrueType type;
-	};
-
-	template<class TrueType, class FalseType>class conditional<false, TrueType, FalseType>
-	{
-	public:
-		typedef FalseType type;
-	};
-
-	namespace detail
-	{
-		//20.3.2...
-		template<class Type>struct identity
-		{
-			typedef Type type;
-		};
-	}
-
-	template<class Type> Type&& forward(typename detail::identity<Type>::type&& type)
-	{
-		return type;
-	}
-
-	template<class Type> typename remove_reference<Type>::type&& move(Type&& type)
-	{
-		return type;
-	}
-
-	template<class Type> void swap(Type& a, Type& b)
-	{
-		Type temp = move(a);
-		a = move(b);
-		b = move(temp);
-	}
+    template<bool, class>class enable_if
+    {
+    };
+
+    template<class Type>class enable_if<true, Type>
+    {
+    public:
+        typedef Type type;
+    };
+
+    template<bool, class TrueType, class>class conditional
+    {
+    public:
+        typedef TrueType type;
+    };
+
+    template<class TrueType, class FalseType>class conditional<false, TrueType, FalseType>
+    {
+    public:
+        typedef FalseType type;
+    };
+
+    namespace detail
+    {
+        //20.3.2...
+        template<class Type>struct identity
+        {
+            typedef Type type;
+        };
+    }
+
+    template<class Type> Type&& forward(typename detail::identity<Type>::type&& type)
+    {
+        return type;
+    }
+
+    template<class Type> typename remove_reference<Type>::type&& move(Type&& type)
+    {
+        return type;
+    }
+
+    template<class Type> void swap(Type& a, Type& b)
+    {
+        Type temp = move(a);
+        a = move(b);
+        b = move(temp);
+    }
 }