diff options
Diffstat (limited to 'boost/poly_collection/detail/type_restitution.hpp')
-rw-r--r-- | boost/poly_collection/detail/type_restitution.hpp | 199 |
1 files changed, 199 insertions, 0 deletions
diff --git a/boost/poly_collection/detail/type_restitution.hpp b/boost/poly_collection/detail/type_restitution.hpp new file mode 100644 index 0000000000..dadd96507b --- /dev/null +++ b/boost/poly_collection/detail/type_restitution.hpp @@ -0,0 +1,199 @@ +/* Copyright 2016-2017 Joaquin M Lopez Munoz. + * 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) + * + * See http://www.boost.org/libs/poly_collection for library home page. + */ + +#ifndef BOOST_POLY_COLLECTION_DETAIL_TYPE_RESTITUTION_HPP +#define BOOST_POLY_COLLECTION_DETAIL_TYPE_RESTITUTION_HPP + +#if defined(_MSC_VER) +#pragma once +#endif + +#include <boost/poly_collection/detail/functional.hpp> +#include <boost/poly_collection/detail/iterator_traits.hpp> +#include <typeinfo> +#include <utility> + +namespace boost{ + +namespace poly_collection{ + +namespace detail{ + +/* Given types Ts..., a const std::type_info& info and a local_base_iterator + * it, we denote by restitute<Ts...>(info,it): + * - a local_iterator<Ti> from it, if info==typeid(Ti) for some Ti in Ts... + * - it otherwise. + * + * Using this notation, restitute_range<Ts...>(f,args...)(s) resolves to + * f(restitute<Ts...>(info,begin),restitute<Ts...>(info,end),args...) where + * info=s.type_info(), begin=s.begin(), end=s.end(). + */ + +template<typename F,typename... Ts> +struct restitute_range_class; + +template<typename F,typename T,typename... Ts> +struct restitute_range_class<F,T,Ts...>: + restitute_range_class<F,Ts...> +{ + using super=restitute_range_class<F,Ts...>; + using super::super; + + template<typename SegmentInfo> + auto operator()(SegmentInfo&& s) + ->decltype(std::declval<F>()(s.begin(),s.end())) + { + using traits=iterator_traits<decltype(s.begin())>; + using local_iterator=typename traits::template local_iterator<T>; + + if(s.type_info()==typeid(T)) + return (this->f)( + local_iterator{s.begin()},local_iterator{s.end()}); + else + return super::operator()(std::forward<SegmentInfo>(s)); + } +}; + +template<typename F> +struct restitute_range_class<F> +{ + restitute_range_class(const F& f):f{f}{} + + template<typename SegmentInfo> + auto operator()(SegmentInfo&& s) + ->decltype(std::declval<F>()(s.begin(),s.end())) + { + return f(s.begin(),s.end()); + } + + F f; +}; + +template<typename... Ts,typename F,typename... Args> +auto restitute_range(const F& f,Args&&... args) + ->restitute_range_class< + decltype(tail_closure(f,std::forward<Args>(args)...)), + Ts... + > +{ + return tail_closure(f,std::forward<Args>(args)...); +} + +/* restitute_iterator<Ts...>(f,args2...)(index,it,args1...) resolves to + * f(restitute<Ts...>(index,it),args1...,args2...). + */ + +template<typename F,typename... Ts> +struct restitute_iterator_class; + +template<typename F,typename T,typename... Ts> +struct restitute_iterator_class<F,T,Ts...>: + restitute_iterator_class<F,Ts...> +{ + using super=restitute_iterator_class<F,Ts...>; + using super::super; + + template<typename Iterator,typename... Args> + auto operator()( + const std::type_info& info,Iterator&& it,Args&&... args) + ->decltype( + std::declval<F>() + (std::forward<Iterator>(it),std::forward<Args>(args)...)) + { + using traits=iterator_traits<typename std::decay<Iterator>::type>; + using local_iterator=typename traits::template local_iterator<T>; + + if(info==typeid(T)) + return (this->f)( + local_iterator{it},std::forward<Args>(args)...); + else + return super::operator()( + info,std::forward<Iterator>(it),std::forward<Args>(args)...); + } +}; + +template<typename F> +struct restitute_iterator_class<F> +{ + restitute_iterator_class(const F& f):f{f}{} + + template<typename Iterator,typename... Args> + auto operator()( + const std::type_info&,Iterator&& it,Args&&... args) + ->decltype( + std::declval<F>() + (std::forward<Iterator>(it),std::forward<Args>(args)...)) + { + return f(std::forward<Iterator>(it),std::forward<Args>(args)...); + } + + F f; +}; + +template<typename... Ts,typename F,typename... Args> +auto restitute_iterator(const F& f,Args&&... args) + ->restitute_iterator_class< + decltype(tail_closure(f,std::forward<Args>(args)...)), + Ts... + > +{ + return tail_closure(f,std::forward<Args>(args)...); +} + +/* binary_restitute_iterator<Ts...>(f,args...)(index1,it1,index2,it2) resolves + * to f(restitute<Ts...>(index1,it1),restitute<Ts...>(index2,it2),args...). + */ + +template<typename F,typename... Ts> +struct binary_restitute_iterator_class +{ + binary_restitute_iterator_class(const F& f):f{f}{} + + template<typename Iterator1,typename Iterator2> + auto operator()( + const std::type_info& info1,Iterator1&& it1, + const std::type_info& info2,Iterator2&& it2) + ->decltype( + std::declval<F>() + (std::forward<Iterator1>(it1),std::forward<Iterator2>(it2))) + { + return restitute_iterator<Ts...>(*this)( + info2,std::forward<Iterator2>(it2),info1,std::forward<Iterator1>(it1)); + } + + template<typename Iterator2,typename Iterator1> + auto operator()( + Iterator2&& it2,const std::type_info& info1,Iterator1&& it1) + ->decltype( + std::declval<F>() + (std::forward<Iterator1>(it1),std::forward<Iterator2>(it2))) + { + return restitute_iterator<Ts...>(f)( + info1,std::forward<Iterator1>(it1),std::forward<Iterator2>(it2)); + } + + F f; +}; + +template<typename... Ts,typename F,typename... Args> +auto binary_restitute_iterator(const F& f,Args&&... args) + ->binary_restitute_iterator_class< + decltype(tail_closure(f,std::forward<Args>(args)...)), + Ts... + > +{ + return tail_closure(f,std::forward<Args>(args)...); +} + +} /* namespace poly_collection::detail */ + +} /* namespace poly_collection */ + +} /* namespace boost */ + +#endif |