1// (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
2// Use, modification, and distribution is subject to the Boost Software
3// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
4// http://www.boost.org/LICENSE_1_0.txt)
5
6// See library home page at http://www.boost.org/libs/numeric/conversion
7//
8// Contact the author at: fernando_cacciola@hotmail.com
9//
10#ifndef BOOST_NUMERIC_CONVERSION_DETAIL_CONVERTER_FLC_12NOV2002_HPP
11#define BOOST_NUMERIC_CONVERSION_DETAIL_CONVERTER_FLC_12NOV2002_HPP
12
13#include <functional>
14
15#include "boost/numeric/conversion/detail/meta.hpp"
16#include "boost/numeric/conversion/detail/conversion_traits.hpp"
17#include "boost/numeric/conversion/bounds.hpp"
18
19#include "boost/type_traits/is_same.hpp"
20
21#include "boost/mpl/integral_c.hpp"
22
23namespace boost { namespace numeric { namespace convdetail
24{
25 // Integral Constants representing rounding modes
26 typedef mpl::integral_c<std::float_round_style, std::round_toward_zero> round2zero_c ;
27 typedef mpl::integral_c<std::float_round_style, std::round_to_nearest> round2nearest_c ;
28 typedef mpl::integral_c<std::float_round_style, std::round_toward_infinity> round2inf_c ;
29 typedef mpl::integral_c<std::float_round_style, std::round_toward_neg_infinity> round2neg_inf_c ;
30
31 // Metafunction:
32 //
33 // for_round_style<RoundStyle,RoundToZero,RoundToNearest,RoundToInf,RoundToNegInf>::type
34 //
35 // {RoundStyle} Integral Constant specifying a round style as declared above.
36 // {RoundToZero,RoundToNearest,RoundToInf,RoundToNegInf} arbitrary types.
37 //
38 // Selects one of the 4 types according to the value of RoundStyle.
39 //
40 template<class RoundStyle,class RoundToZero,class RoundToNearest,class RoundToInf,class RoundToNegInf>
41 struct for_round_style
42 {
43 typedef ct_switch4<RoundStyle
44 , round2zero_c, round2nearest_c, round2inf_c // round2neg_inf_c
45 , RoundToZero , RoundToNearest , RoundToInf , RoundToNegInf
46 > selector ;
47
48 typedef typename selector::type type ;
49 } ;
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68//--------------------------------------------------------------------------
69// Range Checking Logic.
70//
71// The range checking logic is built up by combining 1 or 2 predicates.
72// Each predicate is encapsulated in a template class and exposes
73// the static member function 'apply'.
74//
75//--------------------------------------------------------------------------
76
77
78 // Because a particular logic can combine either 1 or two predicates, the following
79 // tags are used to allow the predicate applier to receive 2 preds, but optimize away
80 // one of them if it is 'non-applicable'
81 struct non_applicable { typedef mpl::false_ do_apply ; } ;
82 struct applicable { typedef mpl::true_ do_apply ; } ;
83
84
85 //--------------------------------------------------------------------------
86 //
87 // Range Checking Logic implementations.
88 //
89 // The following classes, collectivelly named 'Predicates', are instantiated within
90 // the corresponding range checkers.
91 // Their static member function 'apply' is called to perform the actual range checking logic.
92 //--------------------------------------------------------------------------
93
94 // s < Lowest(T) ? cNegOverflow : cInRange
95 //
96 template<class Traits>
97 struct LT_LoT : applicable
98 {
99 typedef typename Traits::target_type T ;
100 typedef typename Traits::source_type S ;
101 typedef typename Traits::argument_type argument_type ;
102
103 static range_check_result apply ( argument_type s )
104 {
105 return s < static_cast<S>(bounds<T>::lowest()) ? cNegOverflow : cInRange ;
106 }
107 } ;
108
109 // s < 0 ? cNegOverflow : cInRange
110 //
111 template<class Traits>
112 struct LT_Zero : applicable
113 {
114 typedef typename Traits::source_type S ;
115 typedef typename Traits::argument_type argument_type ;
116
117 static range_check_result apply ( argument_type s )
118 {
119 return s < static_cast<S>(0) ? cNegOverflow : cInRange ;
120 }
121 } ;
122
123 // s <= Lowest(T)-1 ? cNegOverflow : cInRange
124 //
125 template<class Traits>
126 struct LE_PrevLoT : applicable
127 {
128 typedef typename Traits::target_type T ;
129 typedef typename Traits::source_type S ;
130 typedef typename Traits::argument_type argument_type ;
131
132 static range_check_result apply ( argument_type s )
133 {
134 return s <= static_cast<S>(bounds<T>::lowest()) - static_cast<S>(1.0)
135 ? cNegOverflow : cInRange ;
136 }
137 } ;
138
139 // s < Lowest(T)-0.5 ? cNegOverflow : cInRange
140 //
141 template<class Traits>
142 struct LT_HalfPrevLoT : applicable
143 {
144 typedef typename Traits::target_type T ;
145 typedef typename Traits::source_type S ;
146 typedef typename Traits::argument_type argument_type ;
147
148 static range_check_result apply ( argument_type s )
149 {
150 return s < static_cast<S>(bounds<T>::lowest()) - static_cast<S>(0.5)
151 ? cNegOverflow : cInRange ;
152 }
153 } ;
154
155 // s > Highest(T) ? cPosOverflow : cInRange
156 //
157 template<class Traits>
158 struct GT_HiT : applicable
159 {
160 typedef typename Traits::target_type T ;
161 typedef typename Traits::source_type S ;
162 typedef typename Traits::argument_type argument_type ;
163
164 static range_check_result apply ( argument_type s )
165 {
166 return s > static_cast<S>(bounds<T>::highest())
167 ? cPosOverflow : cInRange ;
168 }
169 } ;
170
171 // s >= Lowest(T) + 1 ? cPosOverflow : cInRange
172 //
173 template<class Traits>
174 struct GE_SuccHiT : applicable
175 {
176 typedef typename Traits::target_type T ;
177 typedef typename Traits::source_type S ;
178 typedef typename Traits::argument_type argument_type ;
179
180 static range_check_result apply ( argument_type s )
181 {
182 return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(1.0)
183 ? cPosOverflow : cInRange ;
184 }
185 } ;
186
187 // s >= Lowest(T) + 0.5 ? cPosgOverflow : cInRange
188 //
189 template<class Traits>
190 struct GT_HalfSuccHiT : applicable
191 {
192 typedef typename Traits::target_type T ;
193 typedef typename Traits::source_type S ;
194 typedef typename Traits::argument_type argument_type ;
195
196 static range_check_result apply ( argument_type s )
197 {
198 return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(0.5)
199 ? cPosOverflow : cInRange ;
200 }
201 } ;
202
203
204 //--------------------------------------------------------------------------
205 //
206 // Predicate Combiner.
207 //
208 // This helper classes are used to possibly combine the range checking logic
209 // individually performed by the predicates
210 //
211 //--------------------------------------------------------------------------
212
213
214 // Applies both predicates: first 'PredA', and if it equals 'cInRange', 'PredB'
215 template<class PredA, class PredB>
216 struct applyBoth
217 {
218 typedef typename PredA::argument_type argument_type ;
219
220 static range_check_result apply ( argument_type s )
221 {
222 range_check_result r = PredA::apply(s) ;
223 if ( r == cInRange )
224 r = PredB::apply(s);
225 return r ;
226 }
227 } ;
228
229 template<class PredA, class PredB>
230 struct combine
231 {
232 typedef applyBoth<PredA,PredB> Both ;
233 typedef void NNone ; // 'None' is defined as a macro in (/usr/X11R6/include/X11/X.h)
234
235 typedef typename PredA::do_apply do_applyA ;
236 typedef typename PredB::do_apply do_applyB ;
237
238 typedef typename for_both<do_applyA, do_applyB, Both, PredA, PredB, NNone>::type type ;
239 } ;
240
241
242
243
244
245
246
247
248
249
250
251
252//--------------------------------------------------------------------------
253// Range Checker classes.
254//
255// The following classes are VISIBLE base classes of the user-level converter<> class.
256// They supply the optimized 'out_of_range()' and 'validate_range()' static member functions
257// visible in the user interface.
258//
259//--------------------------------------------------------------------------
260
261 // Dummy range checker.
262 template<class Traits>
263 struct dummy_range_checker
264 {
265 typedef typename Traits::argument_type argument_type ;
266
267 static range_check_result out_of_range ( argument_type ) { return cInRange ; }
268 static void validate_range ( argument_type ) {}
269 } ;
270
271 // Generic range checker.
272 //
273 // All the range checking logic for all possible combinations of source and target
274 // can be arranged in terms of one or two predicates, which test overflow on both neg/pos 'sides'
275 // of the ranges.
276 //
277 // These predicates are given here as IsNegOverflow and IsPosOverflow.
278 //
279 template<class Traits, class IsNegOverflow, class IsPosOverflow, class OverflowHandler>
280 struct generic_range_checker
281 {
282 typedef OverflowHandler overflow_handler ;
283
284 typedef typename Traits::argument_type argument_type ;
285
286 static range_check_result out_of_range ( argument_type s )
287 {
288 typedef typename combine<IsNegOverflow,IsPosOverflow>::type Predicate ;
289
290 return Predicate::apply(s);
291 }
292
293 static void validate_range ( argument_type s )
294 { OverflowHandler()( out_of_range(s) ) ; }
295 } ;
296
297
298
299//--------------------------------------------------------------------------
300//
301// Selectors for the optimized Range Checker class.
302//
303//--------------------------------------------------------------------------
304
305 template<class Traits,class OverflowHandler>
306 struct GetRC_Sig2Sig_or_Unsig2Unsig
307 {
308 typedef dummy_range_checker<Traits> Dummy ;
309
310 typedef LT_LoT<Traits> Pred1 ;
311 typedef GT_HiT<Traits> Pred2 ;
312
313 typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;
314
315 typedef typename Traits::subranged subranged ;
316
317 typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
318 } ;
319
320 template<class Traits, class OverflowHandler>
321 struct GetRC_Sig2Unsig
322 {
323 typedef LT_Zero<Traits> Pred1 ;
324 typedef GT_HiT <Traits> Pred2 ;
325
326 typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ChoiceA ;
327
328 typedef generic_range_checker<Traits,Pred1,non_applicable,OverflowHandler> ChoiceB ;
329
330 typedef typename Traits::target_type T ;
331 typedef typename Traits::source_type S ;
332
333 typedef typename subranged_Unsig2Sig<S,T>::type oposite_subranged ;
334
335 typedef typename mpl::not_<oposite_subranged>::type positively_subranged ;
336
337 typedef typename mpl::if_<positively_subranged,ChoiceA,ChoiceB>::type type ;
338 } ;
339
340 template<class Traits, class OverflowHandler>
341 struct GetRC_Unsig2Sig
342 {
343 typedef GT_HiT<Traits> Pred1 ;
344
345 typedef generic_range_checker<Traits,non_applicable,Pred1,OverflowHandler> type ;
346 } ;
347
348 template<class Traits,class OverflowHandler>
349 struct GetRC_Int2Int
350 {
351 typedef GetRC_Sig2Sig_or_Unsig2Unsig<Traits,OverflowHandler> Sig2SigQ ;
352 typedef GetRC_Sig2Unsig <Traits,OverflowHandler> Sig2UnsigQ ;
353 typedef GetRC_Unsig2Sig <Traits,OverflowHandler> Unsig2SigQ ;
354 typedef Sig2SigQ Unsig2UnsigQ ;
355
356 typedef typename Traits::sign_mixture sign_mixture ;
357
358 typedef typename
359 for_sign_mixture<sign_mixture,Sig2SigQ,Sig2UnsigQ,Unsig2SigQ,Unsig2UnsigQ>::type
360 selector ;
361
362 typedef typename selector::type type ;
363 } ;
364
365 template<class Traits>
366 struct GetRC_Int2Float
367 {
368 typedef dummy_range_checker<Traits> type ;
369 } ;
370
371 template<class Traits, class OverflowHandler, class Float2IntRounder>
372 struct GetRC_Float2Int
373 {
374 typedef LE_PrevLoT <Traits> Pred1 ;
375 typedef GE_SuccHiT <Traits> Pred2 ;
376 typedef LT_HalfPrevLoT<Traits> Pred3 ;
377 typedef GT_HalfSuccHiT<Traits> Pred4 ;
378 typedef GT_HiT <Traits> Pred5 ;
379 typedef LT_LoT <Traits> Pred6 ;
380
381 typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ToZero ;
382 typedef generic_range_checker<Traits,Pred3,Pred4,OverflowHandler> ToNearest ;
383 typedef generic_range_checker<Traits,Pred1,Pred5,OverflowHandler> ToInf ;
384 typedef generic_range_checker<Traits,Pred6,Pred2,OverflowHandler> ToNegInf ;
385
386 typedef typename Float2IntRounder::round_style round_style ;
387
388 typedef typename for_round_style<round_style,ToZero,ToNearest,ToInf,ToNegInf>::type type ;
389 } ;
390
391 template<class Traits, class OverflowHandler>
392 struct GetRC_Float2Float
393 {
394 typedef dummy_range_checker<Traits> Dummy ;
395
396 typedef LT_LoT<Traits> Pred1 ;
397 typedef GT_HiT<Traits> Pred2 ;
398
399 typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;
400
401 typedef typename Traits::subranged subranged ;
402
403 typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
404 } ;
405
406 template<class Traits, class OverflowHandler, class Float2IntRounder>
407 struct GetRC_BuiltIn2BuiltIn
408 {
409 typedef GetRC_Int2Int<Traits,OverflowHandler> Int2IntQ ;
410 typedef GetRC_Int2Float<Traits> Int2FloatQ ;
411 typedef GetRC_Float2Int<Traits,OverflowHandler,Float2IntRounder> Float2IntQ ;
412 typedef GetRC_Float2Float<Traits,OverflowHandler> Float2FloatQ ;
413
414 typedef typename Traits::int_float_mixture int_float_mixture ;
415
416 typedef typename for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ>::type selector ;
417
418 typedef typename selector::type type ;
419 } ;
420
421 template<class Traits, class OverflowHandler, class Float2IntRounder>
422 struct GetRC
423 {
424 typedef GetRC_BuiltIn2BuiltIn<Traits,OverflowHandler,Float2IntRounder> BuiltIn2BuiltInQ ;
425
426 typedef dummy_range_checker<Traits> Dummy ;
427
428 typedef mpl::identity<Dummy> DummyQ ;
429
430 typedef typename Traits::udt_builtin_mixture udt_builtin_mixture ;
431
432 typedef typename for_udt_builtin_mixture<udt_builtin_mixture,BuiltIn2BuiltInQ,DummyQ,DummyQ,DummyQ>::type selector ;
433
434 typedef typename selector::type type ;
435 } ;
436
437
438
439
440//--------------------------------------------------------------------------
441// Converter classes.
442//
443// The following classes are VISIBLE base classes of the user-level converter<> class.
444// They supply the optimized 'nearbyint()' and 'convert()' static member functions
445// visible in the user interface.
446//
447//--------------------------------------------------------------------------
448
449 //
450 // Trivial Converter : used when (cv-unqualified) T == (cv-unqualified) S
451 //
452 template<class Traits>
453 struct trivial_converter_impl : public dummy_range_checker<Traits>
454 {
455 typedef Traits traits ;
456
457 typedef typename Traits::source_type source_type ;
458 typedef typename Traits::argument_type argument_type ;
459 typedef typename Traits::result_type result_type ;
460
461 static result_type low_level_convert ( argument_type s ) { return s ; }
462 static source_type nearbyint ( argument_type s ) { return s ; }
463 static result_type convert ( argument_type s ) { return s ; }
464 } ;
465
466
467 //
468 // Rounding Converter : used for float to integral conversions.
469 //
470 template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
471 struct rounding_converter : public RangeChecker
472 ,public Float2IntRounder
473 ,public RawConverter
474 {
475 typedef RangeChecker RangeCheckerBase ;
476 typedef Float2IntRounder Float2IntRounderBase ;
477 typedef RawConverter RawConverterBase ;
478
479 typedef Traits traits ;
480
481 typedef typename Traits::source_type source_type ;
482 typedef typename Traits::argument_type argument_type ;
483 typedef typename Traits::result_type result_type ;
484
485 static result_type convert ( argument_type s )
486 {
487 RangeCheckerBase::validate_range(s);
488 source_type s1 = Float2IntRounderBase::nearbyint(s);
489 return RawConverterBase::low_level_convert(s1);
490 }
491 } ;
492
493
494 //
495 // Non-Rounding Converter : used for all other conversions.
496 //
497 template<class Traits,class RangeChecker,class RawConverter>
498 struct non_rounding_converter : public RangeChecker
499 ,public RawConverter
500 {
501 typedef RangeChecker RangeCheckerBase ;
502 typedef RawConverter RawConverterBase ;
503
504 typedef Traits traits ;
505
506 typedef typename Traits::source_type source_type ;
507 typedef typename Traits::argument_type argument_type ;
508 typedef typename Traits::result_type result_type ;
509
510 static source_type nearbyint ( argument_type s ) { return s ; }
511
512 static result_type convert ( argument_type s )
513 {
514 RangeCheckerBase::validate_range(s);
515 return RawConverterBase::low_level_convert(s);
516 }
517 } ;
518
519
520
521
522//--------------------------------------------------------------------------
523//
524// Selectors for the optimized Converter class.
525//
526//--------------------------------------------------------------------------
527
528 template<class Traits,class OverflowHandler,class Float2IntRounder,class RawConverter, class UserRangeChecker>
529 struct get_non_trivial_converter
530 {
531 typedef GetRC<Traits,OverflowHandler,Float2IntRounder> InternalRangeCheckerQ ;
532
533 typedef is_same<UserRangeChecker,UseInternalRangeChecker> use_internal_RC ;
534
535 typedef mpl::identity<UserRangeChecker> UserRangeCheckerQ ;
536
537 typedef typename
538 mpl::eval_if<use_internal_RC,InternalRangeCheckerQ,UserRangeCheckerQ>::type
539 RangeChecker ;
540
541 typedef non_rounding_converter<Traits,RangeChecker,RawConverter> NonRounding ;
542 typedef rounding_converter<Traits,RangeChecker,RawConverter,Float2IntRounder> Rounding ;
543
544 typedef mpl::identity<NonRounding> NonRoundingQ ;
545 typedef mpl::identity<Rounding> RoundingQ ;
546
547 typedef typename Traits::int_float_mixture int_float_mixture ;
548
549 typedef typename
550 for_int_float_mixture<int_float_mixture, NonRoundingQ, NonRoundingQ, RoundingQ, NonRoundingQ>::type
551 selector ;
552
553 typedef typename selector::type type ;
554 } ;
555
556 template< class Traits
557 ,class OverflowHandler
558 ,class Float2IntRounder
559 ,class RawConverter
560 ,class UserRangeChecker
561 >
562 struct get_converter_impl
563 {
564#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x0561 ) )
565 // bcc55 prefers sometimes template parameters to be explicit local types.
566 // (notice that is is illegal to reuse the names like this)
567 typedef Traits Traits ;
568 typedef OverflowHandler OverflowHandler ;
569 typedef Float2IntRounder Float2IntRounder ;
570 typedef RawConverter RawConverter ;
571 typedef UserRangeChecker UserRangeChecker ;
572#endif
573
574 typedef trivial_converter_impl<Traits> Trivial ;
575 typedef mpl::identity <Trivial> TrivialQ ;
576
577 typedef get_non_trivial_converter< Traits
578 ,OverflowHandler
579 ,Float2IntRounder
580 ,RawConverter
581 ,UserRangeChecker
582 > NonTrivialQ ;
583
584 typedef typename Traits::trivial trivial ;
585
586 typedef typename mpl::eval_if<trivial,TrivialQ,NonTrivialQ>::type type ;
587 } ;
588
589} } } // namespace boost::numeric::convdetail
590
591#endif
592
593
594

source code of include/boost/numeric/conversion/detail/converter.hpp