Subject: [Boost-commit] svn:boost r52976 - in sandbox/SOC/2009/fusion/workaround: . conceptgcc conceptgcc/test conceptgcc/test/mini-fusion
From: mr.chr.schmidt_at_[hidden]
Date: 2009-05-13 15:48:03
Author: cschmidt
Date: 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
New Revision: 52976
URL: http://svn.boost.org/trac/boost/changeset/52976
Log:
cleanup
Added:
sandbox/SOC/2009/fusion/workaround/
sandbox/SOC/2009/fusion/workaround/conceptgcc/
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/Jamfile.v2 (contents, props changed)
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/categories.hpp (contents, props changed)
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/concepts.hpp (contents, props changed)
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/convenience.hpp (contents, props changed)
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/test.cpp (contents, props changed)
sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/vector.hpp (contents, props changed)
sandbox/SOC/2009/fusion/workaround/conceptgcc/utility (contents, props changed)
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/Jamfile.v2 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,8 @@
+# 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)
+
+exe mini-fusion : [ glob *.cpp ]
+# : <toolset>gcc-conceptgcc
+ ;
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/categories.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/categories.hpp 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,15 @@
+// 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
+
+namespace boost{namespace fusion{namespace gsoc{
+ 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;
+}}}
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/concepts.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/concepts.hpp 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,77 @@
+// 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 <concepts>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/contains.hpp>
+#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_>;
+ }
+}}}
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/convenience.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/convenience.hpp 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,348 @@
+// 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 "categories.hpp"
+#include "concepts.hpp"
+
+#include <type_traits>
+#include <cstddef>
+
+#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);
+ }
+}}}
+
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/test.cpp 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,147 @@
+// 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)
+
+//!!!These are my local testfiles - hardly any comments, "#pragma once" in headers and #include "" etc.!!!
+
+#include "vector.hpp"
+#include "convenience.hpp"
+#include "concepts.hpp"
+
+#include <cassert>
+
+class copyable
+{
+public:
+ copyable()
+ {
+ }
+ copyable(const copyable&)
+ {
+ }
+ copyable& operator=(const copyable&)
+ {
+ return *this;
+ }
+};
+
+class moveable
+{
+private:
+ moveable(const moveable&);
+
+public:
+ moveable()
+ {
+ }
+ moveable(moveable&&)
+ {
+ }
+ moveable& operator=(moveable&&)
+ {
+ return *this;
+ }
+};
+
+int main()
+{
+ namespace gsoc=boost::fusion::gsoc;
+
+ {
+ 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);
+ }
+
+ return 0;
+}
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/vector.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/test/mini-fusion/vector.hpp 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,382 @@
+// 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 "categories.hpp"
+#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
+ {
+ 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);
+ }
+ };
+ };
+ }
+ }
+}}}
Added: sandbox/SOC/2009/fusion/workaround/conceptgcc/utility
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/workaround/conceptgcc/utility 2009-05-13 15:47:59 EDT (Wed, 13 May 2009)
@@ -0,0 +1,67 @@
+// 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)
+
+//Missing classes in ConceptGCC's <utility> implementation
+#ifndef WORKAROUND_CONCEPTGCC_UTILITY
+#define WORKAROUND_CONCEPTGCC_UTILITY
+
+#include <type_traits>
+#include_next <utility>
+
+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);
+ }
+}
+
+#endif