1/* Copyright 2016-2017 Joaquin M Lopez Munoz.
2 * Distributed under the Boost Software License, Version 1.0.
3 * (See accompanying file LICENSE_1_0.txt or copy at
4 * http://www.boost.org/LICENSE_1_0.txt)
5 *
6 * See http://www.boost.org/libs/poly_collection for library home page.
7 */
8
9#ifndef BOOST_POLY_COLLECTION_DETAIL_TYPE_RESTITUTION_HPP
10#define BOOST_POLY_COLLECTION_DETAIL_TYPE_RESTITUTION_HPP
11
12#if defined(_MSC_VER)
13#pragma once
14#endif
15
16#include <boost/poly_collection/detail/functional.hpp>
17#include <boost/poly_collection/detail/iterator_traits.hpp>
18#include <typeinfo>
19#include <utility>
20
21namespace boost{
22
23namespace poly_collection{
24
25namespace detail{
26
27/* Given types Ts..., a const std::type_info& info and a local_base_iterator
28 * it, we denote by restitute<Ts...>(info,it):
29 * - a local_iterator<Ti> from it, if info==typeid(Ti) for some Ti in Ts...
30 * - it otherwise.
31 *
32 * Using this notation, restitute_range<Ts...>(f,args...)(s) resolves to
33 * f(restitute<Ts...>(info,begin),restitute<Ts...>(info,end),args...) where
34 * info=s.type_info(), begin=s.begin(), end=s.end().
35 */
36
37template<typename F,typename... Ts>
38struct restitute_range_class;
39
40template<typename F,typename T,typename... Ts>
41struct restitute_range_class<F,T,Ts...>:
42 restitute_range_class<F,Ts...>
43{
44 using super=restitute_range_class<F,Ts...>;
45 using super::super;
46
47 template<typename SegmentInfo>
48 auto operator()(SegmentInfo&& s)
49 ->decltype(std::declval<F>()(s.begin(),s.end()))
50 {
51 using traits=iterator_traits<decltype(s.begin())>;
52 using local_iterator=typename traits::template local_iterator<T>;
53
54 if(s.type_info()==typeid(T))
55 return (this->f)(
56 local_iterator{s.begin()},local_iterator{s.end()});
57 else
58 return super::operator()(std::forward<SegmentInfo>(s));
59 }
60};
61
62template<typename F>
63struct restitute_range_class<F>
64{
65 restitute_range_class(const F& f):f(f){}
66
67 template<typename SegmentInfo>
68 auto operator()(SegmentInfo&& s)
69 ->decltype(std::declval<F>()(s.begin(),s.end()))
70 {
71 return f(s.begin(),s.end());
72 }
73
74 F f;
75};
76
77template<typename... Ts,typename F,typename... Args>
78auto restitute_range(const F& f,Args&&... args)
79 ->restitute_range_class<
80 decltype(tail_closure(f,std::forward<Args>(args)...)),
81 Ts...
82 >
83{
84 return tail_closure(f,std::forward<Args>(args)...);
85}
86
87/* restitute_iterator<Ts...>(f,args2...)(index,it,args1...) resolves to
88 * f(restitute<Ts...>(index,it),args1...,args2...).
89 */
90
91template<typename F,typename... Ts>
92struct restitute_iterator_class;
93
94template<typename F,typename T,typename... Ts>
95struct restitute_iterator_class<F,T,Ts...>:
96 restitute_iterator_class<F,Ts...>
97{
98 using super=restitute_iterator_class<F,Ts...>;
99 using super::super;
100
101 template<typename Iterator,typename... Args>
102 auto operator()(
103 const std::type_info& info,Iterator&& it,Args&&... args)
104 ->decltype(
105 std::declval<F>()
106 (std::forward<Iterator>(it),std::forward<Args>(args)...))
107 {
108 using traits=iterator_traits<typename std::decay<Iterator>::type>;
109 using local_iterator=typename traits::template local_iterator<T>;
110
111 if(info==typeid(T))
112 return (this->f)(
113 local_iterator{it},std::forward<Args>(args)...);
114 else
115 return super::operator()(
116 info,std::forward<Iterator>(it),std::forward<Args>(args)...);
117 }
118};
119
120template<typename F>
121struct restitute_iterator_class<F>
122{
123 restitute_iterator_class(const F& f):f(f){}
124
125 template<typename Iterator,typename... Args>
126 auto operator()(
127 const std::type_info&,Iterator&& it,Args&&... args)
128 ->decltype(
129 std::declval<F>()
130 (std::forward<Iterator>(it),std::forward<Args>(args)...))
131 {
132 return f(std::forward<Iterator>(it),std::forward<Args>(args)...);
133 }
134
135 F f;
136};
137
138template<typename... Ts,typename F,typename... Args>
139auto restitute_iterator(const F& f,Args&&... args)
140 ->restitute_iterator_class<
141 decltype(tail_closure(f,std::forward<Args>(args)...)),
142 Ts...
143 >
144{
145 return tail_closure(f,std::forward<Args>(args)...);
146}
147
148/* binary_restitute_iterator<Ts...>(f,args...)(index1,it1,index2,it2) resolves
149 * to f(restitute<Ts...>(index1,it1),restitute<Ts...>(index2,it2),args...).
150 */
151
152template<typename F,typename... Ts>
153struct binary_restitute_iterator_class
154{
155 binary_restitute_iterator_class(const F& f):f(f){}
156
157 template<typename Iterator1,typename Iterator2>
158 auto operator()(
159 const std::type_info& info1,Iterator1&& it1,
160 const std::type_info& info2,Iterator2&& it2)
161 ->decltype(
162 std::declval<F>()
163 (std::forward<Iterator1>(it1),std::forward<Iterator2>(it2)))
164 {
165 return restitute_iterator<Ts...>(*this)(
166 info2,std::forward<Iterator2>(it2),info1,std::forward<Iterator1>(it1));
167 }
168
169 template<typename Iterator2,typename Iterator1>
170 auto operator()(
171 Iterator2&& it2,const std::type_info& info1,Iterator1&& it1)
172 ->decltype(
173 std::declval<F>()
174 (std::forward<Iterator1>(it1),std::forward<Iterator2>(it2)))
175 {
176 return restitute_iterator<Ts...>(f)(
177 info1,std::forward<Iterator1>(it1),std::forward<Iterator2>(it2));
178 }
179
180 F f;
181};
182
183template<typename... Ts,typename F,typename... Args>
184auto binary_restitute_iterator(const F& f,Args&&... args)
185 ->binary_restitute_iterator_class<
186 decltype(tail_closure(f,std::forward<Args>(args)...)),
187 Ts...
188 >
189{
190 return tail_closure(f,std::forward<Args>(args)...);
191}
192
193} /* namespace poly_collection::detail */
194
195} /* namespace poly_collection */
196
197} /* namespace boost */
198
199#endif
200

source code of boost/libs/poly_collection/include/boost/poly_collection/detail/type_restitution.hpp