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

Subject: [Boost-commit] svn:boost r52583 - in sandbox/SOC/2009/fusion: . fusion mini-fusion workaround/conceptgcc
From: mr.chr.schmidt_at_[hidden]
Date: 2009-04-24 19:02:33

Author: cschmidt
Date: 2009-04-24 19:02:31 EDT (Fri, 24 Apr 2009)
New Revision: 52583
URL: http://svn.boost.org/trac/boost/changeset/52583

Log:
Improved mini-fusion to test conceptgcc
Added:
   sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp   (contents, props changed)
   sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp   (contents, props changed)
   sandbox/SOC/2009/fusion/mini-fusion/vector.hpp   (contents, props changed)
Removed:
   sandbox/SOC/2009/fusion/fusion/
Text files modified: 
   sandbox/SOC/2009/fusion/build.bat                     |    10                                         
   sandbox/SOC/2009/fusion/mini-fusion/test.cpp          |   326 +++++++++------------------------------ 
   sandbox/SOC/2009/fusion/workaround/conceptgcc/utility |    12 +                                       
   3 files changed, 96 insertions(+), 252 deletions(-)

Modified: sandbox/SOC/2009/fusion/build.bat
==============================================================================
--- sandbox/SOC/2009/fusion/build.bat	(original)
+++ sandbox/SOC/2009/fusion/build.bat	2009-04-24 19:02:31 EDT (Fri, 24 Apr 2009)
@@ -17,20 +17,20 @@
                 call :gcc
         ) else (
                 if "%1" == "msvc" (
-			call :msvc			
+			call :msvc
                 ) else (
                         if "%1" == "" (
-				call :conceptgcc			
+				call :conceptgcc
                         ) else (
                                 echo Unknown toolset '%1'
-				goto :eof	
+				goto :eof
                         )
                 )
         )
 )
 
 rem compile...
-z:\projekte\cl_link_frontend\tools\bjam --toolset=%TOOLSET% mini-fusion
+z:\projekte\cl_link_frontend\tools\bjam --toolset=%TOOLSET% mini-fusion %2 %3 %4 %5 %6 %7 %8 %9
 goto :eof
 
 :conceptgcc
@@ -53,4 +53,4 @@
 :msvc
 call "%VS90COMNTOOLS%..\..\VC\vcvarsall" x86
 set TOOLSET=msvc
-goto :eof
\ No newline at end of file
+goto :eof

Added: sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/mini-fusion/concepts.hpp	2009-04-24 19:02:31 EDT (Fri, 24 Apr 2009)
@@ -0,0 +1,55 @@
+// Copyright Christopher Schmidt 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#pragma once
+
+//Based on these concepts the convenience functions are implemented!
+
+/*auto concept MetaFunction<class Type>
+{
+	typename type;
+}
+
+auto concept ForwardIterator<class Type>
+{
+	MetaFunction get_next;
+}
+
+auto concept BidirectionalIterator<class Type>
+{
+	requires ForwardIterator<Type>;
+
+	MetaFunction get_prior;
+}
+
+auto concept RandomAccessIterator<class Type>
+{
+	MetaFunction advance;
+	MetaFunction get_distance;
+}
+
+auto concept FusionSequence<class Type>
+{
+	class get_begin;
+	//MetaFunction get_begin;
+	//requires MetaFunction<get_next>;
+	MetaFunction get_end;
+}
+
+auto concept ForwardSequence<class Type>
+{
+	requires FusionSequence<Type>;
+
+	MetaFunction get_size;
+}
+
+auto concept BidirectionalSequence<class Type>
+{
+	requires ForwardSequence<Type>;
+}
+
+auto concept RandomAccessSequence<class Type>
+{
+	requires FusionSequence<Type>;
+}*/

Added: sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/mini-fusion/convenience.hpp	2009-04-24 19:02:31 EDT (Fri, 24 Apr 2009)
@@ -0,0 +1,340 @@
+// Copyright Christopher Schmidt 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#pragma once
+
+//TODO: constexpr!!!
+
+#include <type_traits>
+#include <cstddef>
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost{namespace fusion{namespace gsoc{
+	namespace detail
+	{
+		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:
+			public impl::distance<typename IteratorA::tag>::template apply<IteratorA,IteratorB>
+		{
+			//!!!
+			static_assert(std::is_same<typename IteratorA::tag,typename IteratorB::tag>::value,"Different iterator types specified");
+		};
+	}
+	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:
+			public impl::equal_to<typename IteratorA::tag>::template apply<IteratorA,IteratorB>
+		{
+			static_assert(std::is_same<typename IteratorA::tag,typename IteratorB::tag>::value,"Different iterator types specified");
+		};
+	}
+	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<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-24 19:02:31 EDT (Fri, 24 Apr 2009)
@@ -3,288 +3,122 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <utility>
-#include <concepts>
+//!!!These are my local testfiles - therefore hardly any comments, "#pragma once" in headers and #include ""!!!
 
-#include <boost/mpl/size_t.hpp>
-#include <boost/mpl/bool.hpp>
+#include "vector.hpp"
+#include "convenience.hpp"
 
-namespace boost{namespace fusion{namespace gsoc{
+#include <cassert>
 
-	namespace detail
+class copyable
+{
+public:
+	copyable()
         {
-		template<class... Elements> class vector_impl;
-		template<> class vector_impl<>{};
-
-		template<class Head,class...Other>class vector_impl<Head,Other...> :
-			public vector_impl<Other...>
-		{
-			template<class...> friend class vector_impl;
+	}
+	copyable(const copyable&)
+	{
+	}
+	copyable& operator=(const copyable&)
+	{
+		return *this;
+	}
+};
 
-		private:
-			typedef vector_impl<Other...> base;
+class moveable
+{
+private:
+	moveable(const moveable&);
 
-			Head _element;
+public:
+	moveable()
+	{
+	}
+	moveable(moveable&&)
+	{
+	}
+	moveable& operator=(moveable&&)
+	{
+		return *this;
+	}
+};
 
-		public:
-			vector_impl()
-			{
-			}
+int main()
+{
+	namespace gsoc=boost::fusion::gsoc;
 
-			vector_impl(const vector_impl& other_impl):
-				base(other_impl),
-				_element(other_impl._element)
-			{
-			}
+	{
+		{
+			typedef gsoc::vector<> at;
 
-			vector_impl(vector_impl&& other_impl):
-				base(std::move(other_impl)),
-				_element(std::move(other_impl._element))
                         {
+				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,"");
                         }
 
-			template<class OtherHead,class... OtherElements>vector_impl(const OtherHead& other_head,const OtherElements&... other_elements):
-				base(other_elements...),
-				_element(other_head)
                         {
-			}
+				at a;
 
-			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))
-			{
+				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));
                         }
+		}
 
-			template<class OtherHead,class... OtherElements>vector_impl(const vector_impl<OtherHead,OtherElements...>& other_impl):
-				base(other_impl),
-				_element(other_impl._element)
-			{
-			}
+		{
+			typedef gsoc::vector<long long,float,char> bt;
 
-			template<class OtherHead,class... OtherElements>vector_impl(vector_impl<OtherHead,OtherElements...>&& other_impl):
-				base(std::move(other_impl)),
-				_element(std::move(other_impl._element))
                         {
-			}
+				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,"");
 
-			void operator=(const vector_impl& other_impl)
-			{
-				_element=other_impl._element;
-				static_cast<base&>(*this)=other_impl;
+				static_assert(std::is_same<value_of<begin<bt>::type>::type,long long>::value,"");
                         }
 
-			void operator=(vector_impl&& other_impl)
                         {
-				_element=std::move(other_impl._element);
-				static_cast<base&>(*this)=std::move(other_impl);
-			}
+				bt b(0xDEADBEEF,1337.0f,42);
 
-			template<class OtherHead,class... OtherElements>void operator=(const vector_impl<OtherHead,OtherElements...>& other_impl)
-			{
-				_element=other_impl._element;
-				static_cast<base&>(*this)=other_impl;
-			}
+				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));
 
-			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(other_impl);
+				assert(deref(begin(b))==0xDEADBEEF);
+				at_c<0>(b)=0xBEEFDEEF;
+				assert(at_c<0>(b)==0xBEEFDEEF);
                         }
-		};
-	}
-
-	template<class... Elements>class vector:
-		public detail::vector_impl<Elements...>
-	{
-	private:
-		typedef detail::vector_impl<Elements...> base;
-
-	public:
-		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;
-		}
-	};
-
-	template<class Vector, std::size_t Index> class vector_iterator
-    {
-	public:
-        typedef mpl::size_t<Index> index;
-        typedef Vector vector;
-
-	private:		
-        Vector& _vector;
-
-	public:
-        vector_iterator(Vector& vector):
-			_vector(vector)
-		{
                 }
-    };
-
-	namespace result_of
-	{
-		template<class Sequence>class size;
-		template<class... Elements>class size<vector<Elements...>>
-		{
-		public:
-			typedef mpl::size_t<sizeof...(Elements)> type;
-		};
-
-		template<class Sequence>class empty
-		{
-		public:
-			typedef mpl::bool_<!size<Sequence>::type::value> type;
-		};
-
-		template<class Sequence>class begin;
-		template<class... Elements>class begin<vector<Elements...>>
-		{
-		public:
-			typedef vector_iterator<vector<Elements...>,0> type;
-		};
-
-		template<class Sequence>class end;
-		template<class... Elements>class end<vector<Elements...>>
-		{
-		public:
-			typedef vector_iterator<vector<Elements...>,size<vector<Elements...>>::type::value> type;
-		};
-
-		template<class Sequence>class next;
-		template<class Vector,std::size_type Index>class next<vector_iterator<vector,Index>>
-		{
-		public:
-			typedef vector_iterator<Vector,Index+1> type;
-		};
         }
 
-	template<class Sequence> typename result_of::size<Sequence>::type size(const Sequence&)
         {
-		return typename result_of::size<Sequence>::type();
+		gsoc::vector<moveable,moveable> c;
+		gsoc::vector<moveable,moveable> d;
+		c=std::move(d);
         }
 
-	template<class Sequence> typename result_of::empty<Sequence>::type empty(const Sequence&)
         {
-		return typename result_of::empty<Sequence>::type();
+		gsoc::vector<copyable,copyable> c;
+		gsoc::vector<copyable,copyable> d;
+		c=d;
+		c=std::move(d);
         }
 
-    template<class Sequence> typename result_of::begin<Sequence>::type begin(Sequence& sequence)
-    {
-        return result_of::begin<Sequence>(sequence);
-    }
-
-    template<class Sequence> typename result_of::begin<Sequence const>::type begin(const Sequence& sequence)
-    {
-        return result_of::begin<const Sequence>(sequence);
-    }
-
-    template<class Sequence> typename result_of::end<Sequence>::type end(Sequence& sequence)
-    {
-        return result_of::end<Sequence>(sequence);
-    }
-
-    template<class Sequence> typename result_of::end<Sequence const>::type end(const Sequence& sequence)
-    {
-        return result_of::end<const Sequence>(sequence);
-    }
-}}}
-
-class copyable
-{
-//private:
-	//copyable(copyable&&);
-
-public:
-	copyable()
-	{
-	}
-	copyable(const copyable&)
-	{
-	}
-};
-
-class moveable
-{
-private:
-	moveable(const moveable&);
-
-public:
-	moveable()
         {
+		gsoc::vector<moveable,copyable> c;
+		gsoc::vector<moveable,copyable> d;
+		c=std::move(d);
         }
-	moveable(moveable&&)
-	{
-	}
-};
-
-int main()
-{
-	namespace gsoc=boost::fusion::gsoc;
-	using namespace std;
-
-	gsoc::vector<int,float,char> a;
-	gsoc::vector<int,float,char> b(0,0,0);
-
-	a=b;
-	b=move(a);
-
-	gsoc::vector<moveable,copyable> c;
-	moveable ma;
-	copyable ca;
-	gsoc::vector<moveable,copyable> d(move(ma),move(ca));
-
-	//c=c;
-	//d=move(d);
 
         return 0;
 }

Added: sandbox/SOC/2009/fusion/mini-fusion/vector.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/mini-fusion/vector.hpp	2009-04-24 19:02:31 EDT (Fri, 24 Apr 2009)
@@ -0,0 +1,351 @@
+// Copyright Christopher Schmidt 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#pragma once
+
+#include "convenience.hpp"
+
+#include <utility>
+#include <type_traits>
+#include <cstddef>
+
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace boost{namespace fusion{namespace gsoc{
+	class vector_tag;
+
+	namespace detail
+	{
+		class vector_iterator_tag;
+		template<class Vector,std::size_t Index> class vector_iterator
+		{
+			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 vector_iterator_tag tag;
+
+		private:
+			typedef Vector sequence;
+			typedef mpl::size_t<Index> index;
+
+			Vector& _vector;
+
+			vector_iterator(Vector& vector):
+				_vector(vector)
+			{
+			}
+		};
+
+		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 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);
+					}
+				};
+			};
+		}
+	}
+
+	//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);
+					}
+				};
+			};
+		}
+	}
+
+	//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
+				{
+				public:
+					typedef typename std::add_reference<typename result_of::value_of<Iterator>::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-24 19:02:31 EDT (Fri, 24 Apr 2009)
@@ -10,6 +10,16 @@
 
 namespace std
 {
+	template<bool, class>class enable_if
+	{
+	};
+
+	template<class Type>class enable_if<true, Type>
+	{
+	public:
+		typedef Type type;
+	};
+
         namespace detail
         {
                 //20.3.2...
@@ -35,4 +45,4 @@
                 a = move(b);
                 b = move(temp);
         }
-}
\ No newline at end of file
+}