1 | /*-----------------------------------------------------------------------------+ |
2 | Copyright (c) 2008-2009: Joachim Faulhaber |
3 | +------------------------------------------------------------------------------+ |
4 | Distributed under the Boost Software License, Version 1.0. |
5 | (See accompanying file LICENCE.txt or copy at |
6 | http://www.boost.org/LICENSE_1_0.txt) |
7 | +-----------------------------------------------------------------------------*/ |
8 | #ifndef BOOST_ICL_TEST_VALUE_MAKER_HPP_JOFA_080916 |
9 | #define BOOST_ICL_TEST_VALUE_MAKER_HPP_JOFA_080916 |
10 | |
11 | #include <boost/icl/type_traits/identity_element.hpp> |
12 | #include <boost/icl/interval_bounds.hpp> |
13 | |
14 | namespace boost{ namespace icl |
15 | { |
16 | |
17 | struct mono |
18 | { |
19 | mono(){}; |
20 | mono& operator ++ (){ return *this; } |
21 | mono& operator -- (){ return *this; } |
22 | mono& operator += (const mono&){ return *this; } |
23 | }; |
24 | |
25 | bool operator == (const mono&, const mono&){ return true; } |
26 | bool operator < (const mono&, const mono&){ return false; } |
27 | |
28 | template<class CharType, class CharTraits> |
29 | std::basic_ostream<CharType, CharTraits>& |
30 | operator << (std::basic_ostream<CharType, CharTraits>& stream, const mono& object) |
31 | { |
32 | return stream << "*" ; |
33 | } |
34 | |
35 | |
36 | |
37 | template <class BicrementableT> |
38 | BicrementableT make(int n) |
39 | { |
40 | BicrementableT value = identity_element<BicrementableT>::value(); |
41 | if(n>=0) |
42 | for(int i=0; i<n; i++) |
43 | ++value; |
44 | else |
45 | for(int i=0; i>n; i--) |
46 | --value; |
47 | |
48 | return value; |
49 | } |
50 | |
51 | |
52 | template <class Type> |
53 | struct test_value; |
54 | |
55 | template<> |
56 | struct test_value<std::string> |
57 | { |
58 | static std::string make(int n) |
59 | { |
60 | std::string value = identity_element<std::string>::value(); |
61 | int abs_n = n<0 ? -n : n; |
62 | for(int i=1; i<abs_n; i++) |
63 | value += (i%2==1 ? "hello " : "world " ); |
64 | |
65 | return value; |
66 | } |
67 | }; |
68 | |
69 | |
70 | template <class Type> |
71 | struct test_value<Type*> |
72 | { |
73 | |
74 | static bool map_integers(Type values[], int size) |
75 | { |
76 | static const int offset = size/2; |
77 | for(int idx = 0; idx < size; idx++) |
78 | values[idx] = test_value<Type>::make(idx - offset); |
79 | |
80 | return true; |
81 | } |
82 | |
83 | static Type* make(int n) |
84 | { |
85 | static bool initialized; |
86 | static const int size = 100; |
87 | static const int offset = size/2; |
88 | static Type values[size]; |
89 | |
90 | if(!initialized) |
91 | initialized = map_integers(values, size); |
92 | |
93 | Type* value = values + offset; |
94 | if(n>=0) |
95 | for(int i=0; i<n; i++) |
96 | ++value; |
97 | else |
98 | for(int i=0; i>n; i--) |
99 | --value; |
100 | |
101 | return value; |
102 | } |
103 | }; |
104 | |
105 | |
106 | |
107 | template <class Type> |
108 | struct test_value |
109 | { |
110 | static Type make(int n) |
111 | { |
112 | Type value = identity_element<Type>::value(); |
113 | if(n>=0) |
114 | for(int i=0; i<n; i++) |
115 | ++value; |
116 | else |
117 | for(int i=0; i>n; i--) |
118 | --value; |
119 | |
120 | return value; |
121 | } |
122 | }; |
123 | |
124 | |
125 | template <class ItvMapT> |
126 | struct map_val |
127 | { |
128 | typedef typename ItvMapT::domain_type domain_type; |
129 | typedef typename ItvMapT::codomain_type codomain_type; |
130 | typedef typename ItvMapT::interval_type interval_type; |
131 | typedef typename ItvMapT::value_type value_type; |
132 | typedef typename ItvMapT::segment_type segment_type; |
133 | typedef typename ItvMapT::domain_mapping_type domain_mapping_type; |
134 | typedef std::pair<domain_type, codomain_type> std_pair_type; |
135 | |
136 | static segment_type mk_segment(const interval_type& inter_val, int val) |
137 | { |
138 | return segment_type(inter_val, test_value<codomain_type>::make(val)); |
139 | } |
140 | |
141 | /*CL? |
142 | static interval_type interval_(int lower, int upper, int bounds = 2) |
143 | { |
144 | return segment_type(inter_val, test_value<codomain_type>::make(val)); |
145 | } |
146 | |
147 | static segment_type val_pair(int lower, int upper, int val, int bounds = 2) |
148 | { |
149 | return segment_type( interval_(lower, upper, static_cast<bound_type>(bounds)), |
150 | test_value<codomain_type>::make(val) ); |
151 | } |
152 | */ |
153 | |
154 | static domain_mapping_type map_pair(int key, int val) |
155 | { |
156 | return domain_mapping_type(test_value< domain_type>::make(key), |
157 | test_value<codomain_type>::make(val)); |
158 | } |
159 | |
160 | static std_pair_type std_pair(int key, int val) |
161 | { |
162 | return std_pair_type(test_value< domain_type>::make(key), |
163 | test_value<codomain_type>::make(val)); |
164 | } |
165 | }; |
166 | |
167 | |
168 | // Very short value denotation for intervals |
169 | // Assumption typename T and IntervalT exists in scope |
170 | //I_I : [a,b] |
171 | #define I_I(low,up) icl::interval<T>::closed (test_value<T>::make(low), test_value<T>::make(up)) |
172 | //I_D : [a,b) |
173 | #define I_D(low,up) icl::interval<T>::right_open(test_value<T>::make(low), test_value<T>::make(up)) |
174 | //C_I : (a,b] |
175 | #define C_I(low,up) icl::interval<T>::left_open (test_value<T>::make(low), test_value<T>::make(up)) |
176 | //C_D : (a,b) |
177 | #define C_D(low,up) icl::interval<T>::open (test_value<T>::make(low), test_value<T>::make(up)) |
178 | |
179 | #define MK_I(ItvT,low,up) ItvT(test_value<T>::make(low), test_value<T>::make(up)) |
180 | |
181 | #define MK_v(key) test_value<T>::make(key) |
182 | #define MK_u(key) test_value<U>::make(key) |
183 | |
184 | // Very short value denotation for interval value pairs |
185 | // Assumption typename IntervalMapT existes in scope |
186 | #define IIv(low,up,val) map_val<IntervalMapT>::mk_segment(I_I(low,up), val) |
187 | #define IDv(low,up,val) map_val<IntervalMapT>::mk_segment(I_D(low,up), val) |
188 | #define CIv(low,up,val) map_val<IntervalMapT>::mk_segment(C_I(low,up), val) |
189 | #define CDv(low,up,val) map_val<IntervalMapT>::mk_segment(C_D(low,up), val) |
190 | #define K_v(key,val) map_val<IntervalMapT>::map_pair(key,val) |
191 | #define sK_v(key,val) map_val<IntervalMapT>::std_pair(key,val) |
192 | |
193 | #define MK_seg(itv,val) map_val<IntervalMapT>::mk_segment(itv, val) |
194 | |
195 | |
196 | }} // namespace boost icl |
197 | |
198 | #endif |
199 | |
200 | |