1/*-----------------------------------------------------------------------------+
2Copyright (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
14namespace boost{ namespace icl
15{
16
17struct mono
18{
19 mono(){};
20 mono& operator ++ (){ return *this; }
21 mono& operator -- (){ return *this; }
22 mono& operator += (const mono&){ return *this; }
23};
24
25bool operator == (const mono&, const mono&){ return true; }
26bool operator < (const mono&, const mono&){ return false; }
27
28template<class CharType, class CharTraits>
29std::basic_ostream<CharType, CharTraits>&
30operator << (std::basic_ostream<CharType, CharTraits>& stream, const mono& object)
31{
32 return stream << "*";
33}
34
35
36
37template <class BicrementableT>
38BicrementableT 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
52template <class Type>
53struct test_value;
54
55template<>
56struct 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
70template <class Type>
71struct 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
107template <class Type>
108struct 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
125template <class ItvMapT>
126struct 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

source code of boost/libs/icl/test/test_value_maker.hpp