1 #ifndef UTIL___VALUE_CONVERT__HPP
2 #define UTIL___VALUE_CONVERT__HPP
3
4 /* $Id: value_convert.hpp 601610 2020-02-11 15:01:11Z ucko $
5 * ===========================================================================
6 *
7 * PUBLIC DOMAIN NOTICE
8 * National Center for Biotechnology Information
9 *
10 * This software/database is a "United States Government Work" under the
11 * terms of the United States Copyright Act. It was written as part of
12 * the author's official duties as a United States Government employee and
13 * thus cannot be copyrighted. This software/database is freely available
14 * to the public for use. The National Library of Medicine and the U.S.
15 * Government have not placed any restriction on its use or reproduction.
16 *
17 * Although all reasonable efforts have been taken to ensure the accuracy
18 * and reliability of the software and data, the NLM and the U.S.
19 * Government do not and cannot warrant the performance or results that
20 * may be obtained by using this software or data. The NLM and the U.S.
21 * Government disclaim all warranties, express or implied, including
22 * warranties of performance, merchantability or fitness for any particular
23 * purpose.
24 *
25 * Please cite the author in any work or product based on this material.
26 *
27 * ===========================================================================
28 *
29 * Author: Sergey Sikorskiy
30 *
31 * File Description:
32 *
33 */
34
35
36 #include <corelib/ncbistr.hpp>
37
38 #include "value_convert_policy.hpp"
39
40 BEGIN_NCBI_SCOPE
41
42 #if defined(NCBI_COMPILER_MSVC)
43 # define NCBI_CONVERT_TO(x,y) (x).operator y()
44 #else
45 # define NCBI_CONVERT_TO(x,y) (x)
46 #endif
47
48 namespace value_slice
49 {
50
51
52 ////////////////////////////////////////////////////////////////////////////////
53 // Forward declaration.
54 //
55 template <typename CP, typename FROM> class CValueConvert;
56
57 ////////////////////////////////////////////////////////////////////////////////
58 template <typename CP, typename FROM>
59 inline
MakeCP(const FROM & value)60 CConvPolicy<CP, FROM> MakeCP(const FROM& value)
61 {
62 return CConvPolicy<CP, FROM>(value);
63 }
64
65 ////////////////////////////////////////////////////////////////////////////////
66 template <typename CP>
67 class CValueConvert<CP, string>
68 {
69 public:
70 typedef string obj_type;
71
CValueConvert(const obj_type & value)72 CValueConvert(const obj_type& value)
73 : m_Value(value)
74 {
75 }
76
77 public:
operator obj_type(void) const78 operator obj_type(void) const
79 {
80 return m_Value;
81 }
operator bool(void) const82 operator bool(void) const
83 {
84 return MakeCP<CP>(NStr::StringToBool(m_Value));
85 }
operator Uint1(void) const86 operator Uint1(void) const
87 {
88 return MakeCP<CP>(NStr::StringToUInt(m_Value, NStr::fAllowTrailingSymbols));
89 }
operator Int1(void) const90 operator Int1(void) const
91 {
92 return MakeCP<CP>(NStr::StringToInt(m_Value, NStr::fAllowTrailingSymbols));
93 }
operator Uint2(void) const94 operator Uint2(void) const
95 {
96 return MakeCP<CP>(NStr::StringToUInt(m_Value, NStr::fAllowTrailingSymbols));
97 }
operator Int2(void) const98 operator Int2(void) const
99 {
100 return MakeCP<CP>(NStr::StringToInt(m_Value, NStr::fAllowTrailingSymbols));
101 }
operator Uint4(void) const102 operator Uint4(void) const
103 {
104 return MakeCP<CP>(NStr::StringToUInt(m_Value, NStr::fAllowTrailingSymbols));
105 }
operator Int4(void) const106 operator Int4(void) const
107 {
108 return MakeCP<CP>(NStr::StringToInt(m_Value, NStr::fAllowTrailingSymbols));
109 }
operator unsigned long(void) const110 operator unsigned long(void) const
111 {
112 return MakeCP<CP>(NStr::StringToULong(m_Value, NStr::fAllowTrailingSymbols));
113 }
operator long(void) const114 operator long(void) const
115 {
116 return MakeCP<CP>(NStr::StringToLong(m_Value, NStr::fAllowTrailingSymbols));
117 }
118 #if NCBI_INT8_IS_LONG
operator unsigned long long(void) const119 operator unsigned long long(void) const
120 {
121 return MakeCP<CP>(NStr::StringToUInt8(m_Value, NStr::fAllowTrailingSymbols));
122 }
operator long long(void) const123 operator long long(void) const
124 {
125 return MakeCP<CP>(NStr::StringToInt8(m_Value, NStr::fAllowTrailingSymbols));
126 }
127 #else
operator Uint8(void) const128 operator Uint8(void) const
129 {
130 return MakeCP<CP>(NStr::StringToUInt8(m_Value, NStr::fAllowTrailingSymbols));
131 }
operator Int8(void) const132 operator Int8(void) const
133 {
134 return MakeCP<CP>(NStr::StringToInt8(m_Value, NStr::fAllowTrailingSymbols));
135 }
136 #endif
operator float(void) const137 operator float(void) const
138 {
139 return MakeCP<CP>(NStr::StringToDouble(m_Value));
140 }
operator double(void) const141 operator double(void) const
142 {
143 return MakeCP<CP>(NStr::StringToDouble(m_Value));
144 }
operator long double(void) const145 operator long double(void) const
146 {
147 return MakeCP<CP>(NStr::StringToDouble(m_Value));
148 }
operator CTime(void) const149 operator CTime(void) const
150 {
151 return CTime(m_Value);
152 }
153
154 private:
155 const obj_type m_Value;
156 };
157
158 // Same as CValueConvert<string>
159 template <typename CP>
160 class CValueConvert<CP, const char*>
161 {
162 public:
163 typedef const char* obj_type;
164
CValueConvert(obj_type value)165 CValueConvert(obj_type value)
166 : m_Value(value)
167 {
168 }
169
170 public:
operator bool(void) const171 operator bool(void) const
172 {
173 return MakeCP<CP>(NStr::StringToBool(m_Value));
174 }
operator Uint1(void) const175 operator Uint1(void) const
176 {
177 return MakeCP<CP>(NStr::StringToUInt(m_Value, NStr::fAllowTrailingSymbols));
178 }
operator Int1(void) const179 operator Int1(void) const
180 {
181 return MakeCP<CP>(NStr::StringToInt(m_Value, NStr::fAllowTrailingSymbols));
182 }
operator Uint2(void) const183 operator Uint2(void) const
184 {
185 return MakeCP<CP>(NStr::StringToUInt(m_Value, NStr::fAllowTrailingSymbols));
186 }
operator Int2(void) const187 operator Int2(void) const
188 {
189 return MakeCP<CP>(NStr::StringToInt(m_Value, NStr::fAllowTrailingSymbols));
190 }
operator Uint4(void) const191 operator Uint4(void) const
192 {
193 return MakeCP<CP>(NStr::StringToUInt(m_Value, NStr::fAllowTrailingSymbols));
194 }
operator Int4(void) const195 operator Int4(void) const
196 {
197 return MakeCP<CP>(NStr::StringToInt(m_Value, NStr::fAllowTrailingSymbols));
198 }
operator unsigned long(void) const199 operator unsigned long(void) const
200 {
201 return MakeCP<CP>(NStr::StringToULong(m_Value, NStr::fAllowTrailingSymbols));
202 }
operator long(void) const203 operator long(void) const
204 {
205 return MakeCP<CP>(NStr::StringToLong(m_Value, NStr::fAllowTrailingSymbols));
206 }
207 #if NCBI_INT8_IS_LONG
operator unsigned long long(void) const208 operator unsigned long long(void) const
209 {
210 return MakeCP<CP>(NStr::StringToUInt8(m_Value, NStr::fAllowTrailingSymbols));
211 }
operator long long(void) const212 operator long long(void) const
213 {
214 return MakeCP<CP>(NStr::StringToInt8(m_Value, NStr::fAllowTrailingSymbols));
215 }
216 #else
operator Uint8(void) const217 operator Uint8(void) const
218 {
219 return MakeCP<CP>(NStr::StringToUInt8(m_Value, NStr::fAllowTrailingSymbols));
220 }
operator Int8(void) const221 operator Int8(void) const
222 {
223 return MakeCP<CP>(NStr::StringToInt8(m_Value, NStr::fAllowTrailingSymbols));
224 }
225 #endif
operator float(void) const226 operator float(void) const
227 {
228 return MakeCP<CP>(NStr::StringToDouble(m_Value));
229 }
operator double(void) const230 operator double(void) const
231 {
232 return MakeCP<CP>(NStr::StringToDouble(m_Value));
233 }
operator long double(void) const234 operator long double(void) const
235 {
236 return MakeCP<CP>(NStr::StringToDouble(m_Value));
237 }
operator CTime(void) const238 operator CTime(void) const
239 {
240 return CTime(m_Value);
241 }
242
243 private:
244 obj_type m_Value;
245 };
246
247 template <typename CP>
248 class CValueConvert<CP, bool>
249 {
250 public:
251 typedef bool obj_type;
252
CValueConvert(obj_type value)253 CValueConvert(obj_type value)
254 : m_Value(value)
255 {
256 }
257
258 public:
259 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const260 operator bool(void) const
261 {
262 return m_Value ? 1 : 0;
263 }
operator Uint1(void) const264 operator Uint1(void) const
265 {
266 return m_Value ? 1 : 0;
267 }
operator Int1(void) const268 operator Int1(void) const
269 {
270 return m_Value ? 1 : 0;
271 }
operator Uint2(void) const272 operator Uint2(void) const
273 {
274 return m_Value ? 1 : 0;
275 }
operator Int2(void) const276 operator Int2(void) const
277 {
278 return m_Value ? 1 : 0;
279 }
operator Uint4(void) const280 operator Uint4(void) const
281 {
282 return m_Value ? 1 : 0;
283 }
operator Int4(void) const284 operator Int4(void) const
285 {
286 return m_Value ? 1 : 0;
287 }
operator Uint8(void) const288 operator Uint8(void) const
289 {
290 return m_Value ? 1 : 0;
291 }
operator Int8(void) const292 operator Int8(void) const
293 {
294 return m_Value ? 1 : 0;
295 }
operator float(void) const296 operator float(void) const
297 {
298 return m_Value ? 1.0 : 0.0;
299 }
operator double(void) const300 operator double(void) const
301 {
302 return m_Value ? 1.0 : 0.0;
303 }
operator long double(void) const304 operator long double(void) const
305 {
306 return m_Value ? 1.0 : 0.0;
307 }
308 #else
309 template <typename TO>
310 operator TO(void) const
311 {
312 return m_Value ? static_cast<TO>(1) : static_cast<TO>(0);
313 }
314 #endif
315
operator string(void) const316 operator string(void) const
317 {
318 return NStr::BoolToString(m_Value);
319 }
320
321 private:
322 const obj_type m_Value;
323 };
324
325 template <typename CP>
326 class CValueConvert<CP, Uint1>
327 {
328 public:
329 typedef Uint1 obj_type;
330
CValueConvert(obj_type value)331 CValueConvert(obj_type value)
332 : m_Value(value)
333 {
334 }
335
336 public:
337 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const338 operator bool(void) const
339 {
340 return m_Value != 0;
341 }
operator Uint1(void) const342 operator Uint1(void) const
343 {
344 return MakeCP<CP>(m_Value);
345 }
operator Int1(void) const346 operator Int1(void) const
347 {
348 return MakeCP<CP>(m_Value);
349 }
operator Uint2(void) const350 operator Uint2(void) const
351 {
352 return MakeCP<CP>(m_Value);
353 }
operator Int2(void) const354 operator Int2(void) const
355 {
356 return MakeCP<CP>(m_Value);
357 }
operator Uint4(void) const358 operator Uint4(void) const
359 {
360 return MakeCP<CP>(m_Value);
361 }
operator Int4(void) const362 operator Int4(void) const
363 {
364 return MakeCP<CP>(m_Value);
365 }
operator Uint8(void) const366 operator Uint8(void) const
367 {
368 return MakeCP<CP>(m_Value);
369 }
operator Int8(void) const370 operator Int8(void) const
371 {
372 return MakeCP<CP>(m_Value);
373 }
operator float(void) const374 operator float(void) const
375 {
376 return MakeCP<CP>(m_Value);
377 }
operator double(void) const378 operator double(void) const
379 {
380 return MakeCP<CP>(m_Value);
381 }
operator long double(void) const382 operator long double(void) const
383 {
384 return MakeCP<CP>(m_Value);
385 }
386 #else
387 template <typename TO>
388 operator TO(void) const
389 {
390 return MakeCP<CP>(m_Value);
391 }
392 #endif
operator string(void) const393 operator string(void) const
394 {
395 return NStr::UIntToString(m_Value);
396 }
operator CTime(void) const397 operator CTime(void) const
398 {
399 return CTime(m_Value);
400 }
401
402 private:
403 const obj_type m_Value;
404 };
405
406 template <typename CP>
407 class CValueConvert<CP, Int1>
408 {
409 public:
410 typedef Int1 obj_type;
411
CValueConvert(obj_type value)412 CValueConvert(obj_type value)
413 : m_Value(value)
414 {
415 }
416
417 public:
418 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const419 operator bool(void) const
420 {
421 return m_Value != 0;
422 }
operator Uint1(void) const423 operator Uint1(void) const
424 {
425 return MakeCP<CP>(m_Value);
426 }
operator Int1(void) const427 operator Int1(void) const
428 {
429 return MakeCP<CP>(m_Value);
430 }
operator Uint2(void) const431 operator Uint2(void) const
432 {
433 return MakeCP<CP>(m_Value);
434 }
operator Int2(void) const435 operator Int2(void) const
436 {
437 return MakeCP<CP>(m_Value);
438 }
operator Uint4(void) const439 operator Uint4(void) const
440 {
441 return MakeCP<CP>(m_Value);
442 }
operator Int4(void) const443 operator Int4(void) const
444 {
445 return MakeCP<CP>(m_Value);
446 }
operator Uint8(void) const447 operator Uint8(void) const
448 {
449 return MakeCP<CP>(m_Value);
450 }
operator Int8(void) const451 operator Int8(void) const
452 {
453 return MakeCP<CP>(m_Value);
454 }
operator float(void) const455 operator float(void) const
456 {
457 return MakeCP<CP>(m_Value);
458 }
operator double(void) const459 operator double(void) const
460 {
461 return MakeCP<CP>(m_Value);
462 }
operator long double(void) const463 operator long double(void) const
464 {
465 return MakeCP<CP>(m_Value);
466 }
467 #else
468 template <typename TO>
469 operator TO(void) const
470 {
471 return MakeCP<CP>(m_Value);
472 }
473 #endif
operator string(void) const474 operator string(void) const
475 {
476 return NStr::IntToString(m_Value);
477 }
operator CTime(void) const478 operator CTime(void) const
479 {
480 return CTime(m_Value);
481 }
482
483 private:
484 const obj_type m_Value;
485 };
486
487 template <typename CP>
488 class CValueConvert<CP, Uint2>
489 {
490 public:
491 typedef Uint2 obj_type;
492
CValueConvert(obj_type value)493 CValueConvert(obj_type value)
494 : m_Value(value)
495 {
496 }
497
498 public:
499 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const500 operator bool(void) const
501 {
502 return m_Value != 0;
503 }
operator Uint1(void) const504 operator Uint1(void) const
505 {
506 return MakeCP<CP>(m_Value);
507 }
operator Int1(void) const508 operator Int1(void) const
509 {
510 return MakeCP<CP>(m_Value);
511 }
operator Uint2(void) const512 operator Uint2(void) const
513 {
514 return MakeCP<CP>(m_Value);
515 }
operator Int2(void) const516 operator Int2(void) const
517 {
518 return MakeCP<CP>(m_Value);
519 }
operator Uint4(void) const520 operator Uint4(void) const
521 {
522 return MakeCP<CP>(m_Value);
523 }
operator Int4(void) const524 operator Int4(void) const
525 {
526 return MakeCP<CP>(m_Value);
527 }
operator Uint8(void) const528 operator Uint8(void) const
529 {
530 return MakeCP<CP>(m_Value);
531 }
operator Int8(void) const532 operator Int8(void) const
533 {
534 return MakeCP<CP>(m_Value);
535 }
operator float(void) const536 operator float(void) const
537 {
538 return MakeCP<CP>(m_Value);
539 }
operator double(void) const540 operator double(void) const
541 {
542 return MakeCP<CP>(m_Value);
543 }
operator long double(void) const544 operator long double(void) const
545 {
546 return MakeCP<CP>(m_Value);
547 }
548 #else
549 template <typename TO>
550 operator TO(void) const
551 {
552 return MakeCP<CP>(m_Value);
553 }
554 #endif
operator string(void) const555 operator string(void) const
556 {
557 return NStr::UIntToString(m_Value);
558 }
operator CTime(void) const559 operator CTime(void) const
560 {
561 return CTime(m_Value);
562 }
563
564 private:
565 const obj_type m_Value;
566 };
567
568 template <typename CP>
569 class CValueConvert<CP, Int2>
570 {
571 public:
572 typedef Int2 obj_type;
573
CValueConvert(obj_type value)574 CValueConvert(obj_type value)
575 : m_Value(value)
576 {
577 }
578
579 public:
580 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const581 operator bool(void) const
582 {
583 return m_Value != 0;
584 }
operator Uint1(void) const585 operator Uint1(void) const
586 {
587 return MakeCP<CP>(m_Value);
588 }
operator Int1(void) const589 operator Int1(void) const
590 {
591 return MakeCP<CP>(m_Value);
592 }
operator Uint2(void) const593 operator Uint2(void) const
594 {
595 return MakeCP<CP>(m_Value);
596 }
operator Int2(void) const597 operator Int2(void) const
598 {
599 return MakeCP<CP>(m_Value);
600 }
operator Uint4(void) const601 operator Uint4(void) const
602 {
603 return MakeCP<CP>(m_Value);
604 }
operator Int4(void) const605 operator Int4(void) const
606 {
607 return MakeCP<CP>(m_Value);
608 }
609 #if NCBI_PLATFORM_BITS == 32
operator time_t(void) const610 operator time_t(void) const
611 {
612 return MakeCP<CP>(m_Value);
613 }
614 #endif
operator Uint8(void) const615 operator Uint8(void) const
616 {
617 return MakeCP<CP>(m_Value);
618 }
operator Int8(void) const619 operator Int8(void) const
620 {
621 return MakeCP<CP>(m_Value);
622 }
operator float(void) const623 operator float(void) const
624 {
625 return MakeCP<CP>(m_Value);
626 }
operator double(void) const627 operator double(void) const
628 {
629 return MakeCP<CP>(m_Value);
630 }
operator long double(void) const631 operator long double(void) const
632 {
633 return MakeCP<CP>(m_Value);
634 }
635 #else
636 template <typename TO>
637 operator TO(void) const
638 {
639 return MakeCP<CP>(m_Value);
640 }
641 #endif
operator string(void) const642 operator string(void) const
643 {
644 return NStr::IntToString(m_Value);
645 }
operator CTime(void) const646 operator CTime(void) const
647 {
648 return CTime(m_Value);
649 }
650
651 private:
652 const obj_type m_Value;
653 };
654
655 template <typename CP>
656 class CValueConvert<CP, Uint4>
657 {
658 public:
659 typedef Uint4 obj_type;
660
CValueConvert(obj_type value)661 CValueConvert(obj_type value)
662 : m_Value(value)
663 {
664 }
665
666 public:
667 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const668 operator bool(void) const
669 {
670 return m_Value != 0;
671 }
operator Uint1(void) const672 operator Uint1(void) const
673 {
674 return MakeCP<CP>(m_Value);
675 }
operator Int1(void) const676 operator Int1(void) const
677 {
678 return MakeCP<CP>(m_Value);
679 }
operator Uint2(void) const680 operator Uint2(void) const
681 {
682 return MakeCP<CP>(m_Value);
683 }
operator Int2(void) const684 operator Int2(void) const
685 {
686 return MakeCP<CP>(m_Value);
687 }
operator Uint4(void) const688 operator Uint4(void) const
689 {
690 return MakeCP<CP>(m_Value);
691 }
operator Int4(void) const692 operator Int4(void) const
693 {
694 return MakeCP<CP>(m_Value);
695 }
operator Uint8(void) const696 operator Uint8(void) const
697 {
698 return MakeCP<CP>(m_Value);
699 }
operator Int8(void) const700 operator Int8(void) const
701 {
702 return MakeCP<CP>(m_Value);
703 }
operator float(void) const704 operator float(void) const
705 {
706 return MakeCP<CP>(m_Value);
707 }
operator double(void) const708 operator double(void) const
709 {
710 return MakeCP<CP>(m_Value);
711 }
operator long double(void) const712 operator long double(void) const
713 {
714 return MakeCP<CP>(m_Value);
715 }
716 #else
717 template <typename TO>
718 operator TO(void) const
719 {
720 return MakeCP<CP>(m_Value);
721 }
722 #endif
operator string(void) const723 operator string(void) const
724 {
725 return NStr::UIntToString(m_Value);
726 }
operator CTime(void) const727 operator CTime(void) const
728 {
729 return CTime(MakeCP<CP>(m_Value));
730 }
731
732 private:
733 const obj_type m_Value;
734 };
735
736 template <typename CP>
737 class CValueConvert<CP, Int4>
738 {
739 public:
740 typedef Int4 obj_type;
741
CValueConvert(obj_type value)742 CValueConvert(obj_type value)
743 : m_Value(value)
744 {
745 }
746
747 public:
748 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const749 operator bool(void) const
750 {
751 return m_Value != 0;
752 }
operator Uint1(void) const753 operator Uint1(void) const
754 {
755 return MakeCP<CP>(m_Value);
756 }
operator Int1(void) const757 operator Int1(void) const
758 {
759 return MakeCP<CP>(m_Value);
760 }
operator Uint2(void) const761 operator Uint2(void) const
762 {
763 return MakeCP<CP>(m_Value);
764 }
operator Int2(void) const765 operator Int2(void) const
766 {
767 return MakeCP<CP>(m_Value);
768 }
operator Uint4(void) const769 operator Uint4(void) const
770 {
771 return MakeCP<CP>(m_Value);
772 }
operator Int4(void) const773 operator Int4(void) const
774 {
775 return MakeCP<CP>(m_Value);
776 }
777 #if NCBI_PLATFORM_BITS == 32
operator time_t(void) const778 operator time_t(void) const
779 {
780 return MakeCP<CP>(m_Value);
781 }
782 #endif
operator Uint8(void) const783 operator Uint8(void) const
784 {
785 return MakeCP<CP>(m_Value);
786 }
operator Int8(void) const787 operator Int8(void) const
788 {
789 return MakeCP<CP>(m_Value);
790 }
operator float(void) const791 operator float(void) const
792 {
793 return MakeCP<CP>(m_Value);
794 }
operator double(void) const795 operator double(void) const
796 {
797 return MakeCP<CP>(m_Value);
798 }
operator long double(void) const799 operator long double(void) const
800 {
801 return MakeCP<CP>(m_Value);
802 }
803 #else
804 template <typename TO>
805 operator TO(void) const
806 {
807 return MakeCP<CP>(m_Value);
808 }
809 #endif
operator string(void) const810 operator string(void) const
811 {
812 return NStr::IntToString(m_Value);
813 }
operator CTime(void) const814 operator CTime(void) const
815 {
816 return CTime(MakeCP<CP>(m_Value));
817 }
818
819 private:
820 const obj_type m_Value;
821 };
822
823 template <typename CP>
824 class CValueConvert<CP, unsigned long>
825 {
826 public:
827 typedef unsigned long obj_type;
828
CValueConvert(obj_type value)829 CValueConvert(obj_type value)
830 : m_Value(value)
831 {
832 }
833
834 public:
835 template <typename TO>
operator TO(void) const836 operator TO(void) const
837 {
838 return MakeCP<CP>(m_Value);
839 }
operator string(void) const840 operator string(void) const
841 {
842 return NStr::ULongToString(m_Value);
843 }
operator CTime(void) const844 operator CTime(void) const
845 {
846 return CTime(MakeCP<CP>(m_Value));
847 }
848
849 private:
850 const obj_type m_Value;
851 };
852
853 template <typename CP>
854 class CValueConvert<CP, long>
855 {
856 public:
857 typedef long obj_type;
858
CValueConvert(obj_type value)859 CValueConvert(obj_type value)
860 : m_Value(value)
861 {
862 }
863
864 public:
865 template <typename TO>
operator TO(void) const866 operator TO(void) const
867 {
868 return MakeCP<CP>(m_Value);
869 }
operator string(void) const870 operator string(void) const
871 {
872 return NStr::LongToString(m_Value);
873 }
operator CTime(void) const874 operator CTime(void) const
875 {
876 return CTime(MakeCP<CP>(m_Value));
877 }
878
879 private:
880 const obj_type m_Value;
881 };
882
883 #if NCBI_INT8_IS_LONG
884 template <typename CP>
885 class CValueConvert<CP, unsigned long long>
886 {
887 public:
888 typedef unsigned long long obj_type;
889
CValueConvert(obj_type value)890 CValueConvert(obj_type value)
891 : m_Value(value)
892 {
893 }
894
895 public:
896 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const897 operator bool(void) const
898 {
899 return m_Value != 0;
900 }
operator Uint1(void) const901 operator Uint1(void) const
902 {
903 return MakeCP<CP>(m_Value);
904 }
operator Int1(void) const905 operator Int1(void) const
906 {
907 return MakeCP<CP>(m_Value);
908 }
operator Uint2(void) const909 operator Uint2(void) const
910 {
911 return MakeCP<CP>(m_Value);
912 }
operator Int2(void) const913 operator Int2(void) const
914 {
915 return MakeCP<CP>(m_Value);
916 }
operator Uint4(void) const917 operator Uint4(void) const
918 {
919 return MakeCP<CP>(m_Value);
920 }
operator Int4(void) const921 operator Int4(void) const
922 {
923 return MakeCP<CP>(m_Value);
924 }
operator Uint8(void) const925 operator Uint8(void) const
926 {
927 return MakeCP<CP>(m_Value);
928 }
operator Int8(void) const929 operator Int8(void) const
930 {
931 return MakeCP<CP>(m_Value);
932 }
operator float(void) const933 operator float(void) const
934 {
935 return MakeCP<CP>(m_Value);
936 }
operator double(void) const937 operator double(void) const
938 {
939 return MakeCP<CP>(m_Value);
940 }
operator long double(void) const941 operator long double(void) const
942 {
943 return MakeCP<CP>(m_Value);
944 }
945 #else
946 template <typename TO>
947 operator TO(void) const
948 {
949 return MakeCP<CP>(m_Value);
950 }
951 #endif
operator string(void) const952 operator string(void) const
953 {
954 return NStr::UInt8ToString(m_Value);
955 }
operator CTime(void) const956 operator CTime(void) const
957 {
958 return CTime(MakeCP<CP>(m_Value));
959 }
960
961 private:
962 const obj_type m_Value;
963 };
964
965 template <typename CP>
966 class CValueConvert<CP, long long>
967 {
968 public:
969 typedef long long obj_type;
970
CValueConvert(obj_type value)971 CValueConvert(obj_type value)
972 : m_Value(value)
973 {
974 }
975
976 public:
977 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const978 operator bool(void) const
979 {
980 return m_Value != 0;
981 }
operator Uint1(void) const982 operator Uint1(void) const
983 {
984 return MakeCP<CP>(m_Value);
985 }
operator Int1(void) const986 operator Int1(void) const
987 {
988 return MakeCP<CP>(m_Value);
989 }
operator Uint2(void) const990 operator Uint2(void) const
991 {
992 return MakeCP<CP>(m_Value);
993 }
operator Int2(void) const994 operator Int2(void) const
995 {
996 return MakeCP<CP>(m_Value);
997 }
operator Uint4(void) const998 operator Uint4(void) const
999 {
1000 return MakeCP<CP>(m_Value);
1001 }
operator Int4(void) const1002 operator Int4(void) const
1003 {
1004 return MakeCP<CP>(m_Value);
1005 }
1006 #if NCBI_PLATFORM_BITS == 32
operator time_t(void) const1007 operator time_t(void) const
1008 {
1009 return MakeCP<CP>(m_Value);
1010 }
1011 #endif
operator Uint8(void) const1012 operator Uint8(void) const
1013 {
1014 return MakeCP<CP>(m_Value);
1015 }
operator Int8(void) const1016 operator Int8(void) const
1017 {
1018 return MakeCP<CP>(m_Value);
1019 }
operator float(void) const1020 operator float(void) const
1021 {
1022 return MakeCP<CP>(m_Value);
1023 }
operator double(void) const1024 operator double(void) const
1025 {
1026 return MakeCP<CP>(m_Value);
1027 }
operator long double(void) const1028 operator long double(void) const
1029 {
1030 return MakeCP<CP>(m_Value);
1031 }
1032 #else
1033 template <typename TO>
1034 operator TO(void) const
1035 {
1036 return MakeCP<CP>(m_Value);
1037 }
1038 #endif
operator string(void) const1039 operator string(void) const
1040 {
1041 return NStr::Int8ToString(m_Value);
1042 }
operator CTime(void) const1043 operator CTime(void) const
1044 {
1045 return CTime(MakeCP<CP>(m_Value));
1046 }
1047
1048 private:
1049 const obj_type m_Value;
1050 };
1051 #else
1052 template <typename CP>
1053 class CValueConvert<CP, Uint8>
1054 {
1055 public:
1056 typedef Uint8 obj_type;
1057
CValueConvert(obj_type value)1058 CValueConvert(obj_type value)
1059 : m_Value(value)
1060 {
1061 }
1062
1063 public:
1064 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const1065 operator bool(void) const
1066 {
1067 return m_Value != 0;
1068 }
operator Uint1(void) const1069 operator Uint1(void) const
1070 {
1071 return MakeCP<CP>(m_Value);
1072 }
operator Int1(void) const1073 operator Int1(void) const
1074 {
1075 return MakeCP<CP>(m_Value);
1076 }
operator Uint2(void) const1077 operator Uint2(void) const
1078 {
1079 return MakeCP<CP>(m_Value);
1080 }
operator Int2(void) const1081 operator Int2(void) const
1082 {
1083 return MakeCP<CP>(m_Value);
1084 }
operator Uint4(void) const1085 operator Uint4(void) const
1086 {
1087 return MakeCP<CP>(m_Value);
1088 }
operator Int4(void) const1089 operator Int4(void) const
1090 {
1091 return MakeCP<CP>(m_Value);
1092 }
operator Uint8(void) const1093 operator Uint8(void) const
1094 {
1095 return MakeCP<CP>(m_Value);
1096 }
operator Int8(void) const1097 operator Int8(void) const
1098 {
1099 return MakeCP<CP>(m_Value);
1100 }
operator float(void) const1101 operator float(void) const
1102 {
1103 return MakeCP<CP>(m_Value);
1104 }
operator double(void) const1105 operator double(void) const
1106 {
1107 return MakeCP<CP>(m_Value);
1108 }
operator long double(void) const1109 operator long double(void) const
1110 {
1111 return MakeCP<CP>(m_Value);
1112 }
1113 #else
1114 template <typename TO>
1115 operator TO(void) const
1116 {
1117 return MakeCP<CP>(m_Value);
1118 }
1119 #endif
operator string(void) const1120 operator string(void) const
1121 {
1122 return NStr::UInt8ToString(m_Value);
1123 }
operator CTime(void) const1124 operator CTime(void) const
1125 {
1126 return CTime(MakeCP<CP>(m_Value));
1127 }
1128
1129 private:
1130 const obj_type m_Value;
1131 };
1132
1133 template <typename CP>
1134 class CValueConvert<CP, Int8>
1135 {
1136 public:
1137 typedef Int8 obj_type;
1138
CValueConvert(obj_type value)1139 CValueConvert(obj_type value)
1140 : m_Value(value)
1141 {
1142 }
1143
1144 public:
1145 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const1146 operator bool(void) const
1147 {
1148 return m_Value != 0;
1149 }
operator Uint1(void) const1150 operator Uint1(void) const
1151 {
1152 return MakeCP<CP>(m_Value);
1153 }
operator Int1(void) const1154 operator Int1(void) const
1155 {
1156 return MakeCP<CP>(m_Value);
1157 }
operator Uint2(void) const1158 operator Uint2(void) const
1159 {
1160 return MakeCP<CP>(m_Value);
1161 }
operator Int2(void) const1162 operator Int2(void) const
1163 {
1164 return MakeCP<CP>(m_Value);
1165 }
operator Uint4(void) const1166 operator Uint4(void) const
1167 {
1168 return MakeCP<CP>(m_Value);
1169 }
operator Int4(void) const1170 operator Int4(void) const
1171 {
1172 return MakeCP<CP>(m_Value);
1173 }
1174 #if NCBI_PLATFORM_BITS == 32
operator time_t(void) const1175 operator time_t(void) const
1176 {
1177 return MakeCP<CP>(m_Value);
1178 }
1179 #endif
operator Uint8(void) const1180 operator Uint8(void) const
1181 {
1182 return MakeCP<CP>(m_Value);
1183 }
operator Int8(void) const1184 operator Int8(void) const
1185 {
1186 return MakeCP<CP>(m_Value);
1187 }
operator float(void) const1188 operator float(void) const
1189 {
1190 return MakeCP<CP>(m_Value);
1191 }
operator double(void) const1192 operator double(void) const
1193 {
1194 return MakeCP<CP>(m_Value);
1195 }
operator long double(void) const1196 operator long double(void) const
1197 {
1198 return MakeCP<CP>(m_Value);
1199 }
1200 #else
1201 template <typename TO>
1202 operator TO(void) const
1203 {
1204 return MakeCP<CP>(m_Value);
1205 }
1206 #endif
operator string(void) const1207 operator string(void) const
1208 {
1209 return NStr::Int8ToString(m_Value);
1210 }
operator CTime(void) const1211 operator CTime(void) const
1212 {
1213 return CTime(MakeCP<CP>(m_Value));
1214 }
1215
1216 private:
1217 const obj_type m_Value;
1218 };
1219 #endif
1220
1221 template <typename CP>
1222 class CValueConvert<CP, float>
1223 {
1224 public:
1225 typedef float obj_type;
1226
CValueConvert(obj_type value)1227 CValueConvert(obj_type value)
1228 : m_Value(value)
1229 {
1230 }
1231
1232 public:
1233 #if defined(NCBI_COMPILER_MSVC)
operator bool(void) const1234 operator bool(void) const
1235 {
1236 return m_Value != 0.0F;
1237 }
1238 #endif
1239 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const1240 operator bool(void) const
1241 {
1242 return m_Value != 0.0F;
1243 }
operator Uint1(void) const1244 operator Uint1(void) const
1245 {
1246 return MakeCP<CP>(m_Value);
1247 }
operator Int1(void) const1248 operator Int1(void) const
1249 {
1250 return MakeCP<CP>(m_Value);
1251 }
operator Uint2(void) const1252 operator Uint2(void) const
1253 {
1254 return MakeCP<CP>(m_Value);
1255 }
operator Int2(void) const1256 operator Int2(void) const
1257 {
1258 return MakeCP<CP>(m_Value);
1259 }
operator Uint4(void) const1260 operator Uint4(void) const
1261 {
1262 return MakeCP<CP>(m_Value);
1263 }
operator Int4(void) const1264 operator Int4(void) const
1265 {
1266 return MakeCP<CP>(m_Value);
1267 }
1268 #if NCBI_PLATFORM_BITS == 32
operator time_t(void) const1269 operator time_t(void) const
1270 {
1271 return MakeCP<CP>(m_Value);
1272 }
1273 #endif
operator Uint8(void) const1274 operator Uint8(void) const
1275 {
1276 return MakeCP<CP>(m_Value);
1277 }
operator Int8(void) const1278 operator Int8(void) const
1279 {
1280 return MakeCP<CP>(m_Value);
1281 }
operator float(void) const1282 operator float(void) const
1283 {
1284 return MakeCP<CP>(m_Value);
1285 }
operator double(void) const1286 operator double(void) const
1287 {
1288 return MakeCP<CP>(m_Value);
1289 }
operator long double(void) const1290 operator long double(void) const
1291 {
1292 return MakeCP<CP>(m_Value);
1293 }
1294 #else
1295 template <typename TO>
operator TO(void) const1296 operator TO(void) const
1297 {
1298 return MakeCP<CP>(m_Value);
1299 }
1300 #endif
operator string(void) const1301 operator string(void) const
1302 {
1303 string value;
1304 NStr::DoubleToString(value, m_Value);
1305
1306 return value;
1307 }
1308
1309 private:
1310 const obj_type m_Value;
1311 };
1312
1313 template <typename CP>
1314 class CValueConvert<CP, double>
1315 {
1316 public:
1317 typedef double obj_type;
1318
CValueConvert(obj_type value)1319 CValueConvert(obj_type value)
1320 : m_Value(value)
1321 {
1322 }
1323
1324 public:
1325 #if defined(NCBI_COMPILER_MSVC)
operator bool(void) const1326 operator bool(void) const
1327 {
1328 return m_Value != 0.0;
1329 }
1330 #endif
1331 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const1332 operator bool(void) const
1333 {
1334 return m_Value != 0.0;
1335 }
operator Uint1(void) const1336 operator Uint1(void) const
1337 {
1338 return MakeCP<CP>(m_Value);
1339 }
operator Int1(void) const1340 operator Int1(void) const
1341 {
1342 return MakeCP<CP>(m_Value);
1343 }
operator Uint2(void) const1344 operator Uint2(void) const
1345 {
1346 return MakeCP<CP>(m_Value);
1347 }
operator Int2(void) const1348 operator Int2(void) const
1349 {
1350 return MakeCP<CP>(m_Value);
1351 }
operator Uint4(void) const1352 operator Uint4(void) const
1353 {
1354 return MakeCP<CP>(m_Value);
1355 }
operator Int4(void) const1356 operator Int4(void) const
1357 {
1358 return MakeCP<CP>(m_Value);
1359 }
1360 #if NCBI_PLATFORM_BITS == 32
operator time_t(void) const1361 operator time_t(void) const
1362 {
1363 return MakeCP<CP>(m_Value);
1364 }
1365 #endif
operator Uint8(void) const1366 operator Uint8(void) const
1367 {
1368 return MakeCP<CP>(m_Value);
1369 }
operator Int8(void) const1370 operator Int8(void) const
1371 {
1372 return MakeCP<CP>(m_Value);
1373 }
operator float(void) const1374 operator float(void) const
1375 {
1376 return MakeCP<CP>(m_Value);
1377 }
operator double(void) const1378 operator double(void) const
1379 {
1380 return MakeCP<CP>(m_Value);
1381 }
operator long double(void) const1382 operator long double(void) const
1383 {
1384 return MakeCP<CP>(m_Value);
1385 }
1386 #else
1387 template <typename TO>
operator TO(void) const1388 operator TO(void) const
1389 {
1390 return MakeCP<CP>(m_Value);
1391 }
1392 #endif
operator string(void) const1393 operator string(void) const
1394 {
1395 string value;
1396 NStr::DoubleToString(value, m_Value);
1397
1398 return value;
1399 }
1400
1401 private:
1402 const obj_type m_Value;
1403 };
1404
1405 template <typename CP>
1406 class CValueConvert<CP, long double>
1407 {
1408 public:
1409 typedef long double obj_type;
1410
CValueConvert(obj_type value)1411 CValueConvert(obj_type value)
1412 : m_Value(value)
1413 {
1414 }
1415
1416 public:
1417 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const1418 operator bool(void) const
1419 {
1420 return m_Value != 0.0L;
1421 }
operator Uint1(void) const1422 operator Uint1(void) const
1423 {
1424 return MakeCP<CP>(m_Value);
1425 }
operator Int1(void) const1426 operator Int1(void) const
1427 {
1428 return MakeCP<CP>(m_Value);
1429 }
operator Uint2(void) const1430 operator Uint2(void) const
1431 {
1432 return MakeCP<CP>(m_Value);
1433 }
operator Int2(void) const1434 operator Int2(void) const
1435 {
1436 return MakeCP<CP>(m_Value);
1437 }
operator Uint4(void) const1438 operator Uint4(void) const
1439 {
1440 return MakeCP<CP>(m_Value);
1441 }
operator Int4(void) const1442 operator Int4(void) const
1443 {
1444 return MakeCP<CP>(m_Value);
1445 }
operator Uint8(void) const1446 operator Uint8(void) const
1447 {
1448 return MakeCP<CP>(m_Value);
1449 }
operator Int8(void) const1450 operator Int8(void) const
1451 {
1452 return MakeCP<CP>(m_Value);
1453 }
operator float(void) const1454 operator float(void) const
1455 {
1456 return MakeCP<CP>(m_Value);
1457 }
operator double(void) const1458 operator double(void) const
1459 {
1460 return MakeCP<CP>(m_Value);
1461 }
operator long double(void) const1462 operator long double(void) const
1463 {
1464 return MakeCP<CP>(m_Value);
1465 }
1466 #else
1467 template <typename TO>
1468 operator TO(void) const
1469 {
1470 return MakeCP<CP>(m_Value);
1471 }
1472 #endif
1473
1474 private:
1475 const obj_type m_Value;
1476 };
1477
1478 template <typename CP>
1479 class CValueConvert<CP, CTime>
1480 {
1481 public:
1482 typedef CTime obj_type;
1483
CValueConvert(const obj_type & value)1484 CValueConvert(const obj_type& value)
1485 : m_Value(&value)
1486 {
1487 }
1488
1489 public:
1490 #if defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550
operator bool(void) const1491 operator bool(void) const
1492 {
1493 return !m_Value->IsEmpty();
1494 }
operator Uint1(void) const1495 operator Uint1(void) const
1496 {
1497 return MakeCP<CP>(*m_Value);
1498 }
operator Int1(void) const1499 operator Int1(void) const
1500 {
1501 return MakeCP<CP>(m_Value);
1502 }
operator Uint2(void) const1503 operator Uint2(void) const
1504 {
1505 return MakeCP<CP>(*m_Value);
1506 }
operator Int2(void) const1507 operator Int2(void) const
1508 {
1509 return MakeCP<CP>(*m_Value);
1510 }
operator Uint4(void) const1511 operator Uint4(void) const
1512 {
1513 return MakeCP<CP>(*m_Value);
1514 }
operator Int4(void) const1515 operator Int4(void) const
1516 {
1517 return MakeCP<CP>(*m_Value);
1518 }
operator Uint8(void) const1519 operator Uint8(void) const
1520 {
1521 return MakeCP<CP>(*m_Value);
1522 }
operator Int8(void) const1523 operator Int8(void) const
1524 {
1525 return MakeCP<CP>(*m_Value);
1526 }
operator float(void) const1527 operator float(void) const
1528 {
1529 return MakeCP<CP>(*m_Value);
1530 }
operator double(void) const1531 operator double(void) const
1532 {
1533 return MakeCP<CP>(*m_Value);
1534 }
1535 #else
1536 template <typename TO>
1537 operator TO(void) const
1538 {
1539 return MakeCP<CP>(*m_Value);
1540 }
1541 #endif
1542
1543 // Convert to itself.
operator const obj_type&(void) const1544 operator const obj_type&(void) const
1545 {
1546 return MakeCP<CP>(*m_Value);
1547 }
operator string(void) const1548 operator string(void) const
1549 {
1550 return m_Value->AsString();
1551 }
1552
1553 private:
1554 const obj_type* m_Value;
1555 };
1556
1557 ////////////////////////////////////////////////////////////////////////////////
1558 // Specializations for conversion to bool.
1559 #if !(defined(NCBI_COMPILER_WORKSHOP) && NCBI_COMPILER_VERSION <= 550)
1560 template <> template <>
1561 inline
operator bool(void) const1562 CValueConvert<SSafeCP, Uint1>::operator bool(void) const
1563 {
1564 return m_Value != 0;
1565 }
1566
1567 template <> template <>
1568 inline
operator bool(void) const1569 CValueConvert<SRunTimeCP, Uint1>::operator bool(void) const
1570 {
1571 return m_Value != 0;
1572 }
1573
1574 template <> template <>
1575 inline
operator bool(void) const1576 CValueConvert<SSafeCP, Int1>::operator bool(void) const
1577 {
1578 return m_Value != 0;
1579 }
1580
1581 template <> template <>
1582 inline
operator bool(void) const1583 CValueConvert<SRunTimeCP, Int1>::operator bool(void) const
1584 {
1585 return m_Value != 0;
1586 }
1587
1588 template <> template <>
1589 inline
operator bool(void) const1590 CValueConvert<SSafeCP, Uint2>::operator bool(void) const
1591 {
1592 return m_Value != 0;
1593 }
1594
1595 template <> template <>
1596 inline
operator bool(void) const1597 CValueConvert<SRunTimeCP, Uint2>::operator bool(void) const
1598 {
1599 return m_Value != 0;
1600 }
1601
1602 template <> template <>
1603 inline
operator bool(void) const1604 CValueConvert<SSafeCP, Int2>::operator bool(void) const
1605 {
1606 return m_Value != 0;
1607 }
1608
1609 template <> template <>
1610 inline
operator bool(void) const1611 CValueConvert<SRunTimeCP, Int2>::operator bool(void) const
1612 {
1613 return m_Value != 0;
1614 }
1615
1616 template <> template <>
1617 inline
operator bool(void) const1618 CValueConvert<SSafeCP, Uint4>::operator bool(void) const
1619 {
1620 return m_Value != 0;
1621 }
1622
1623 template <> template <>
1624 inline
operator bool(void) const1625 CValueConvert<SRunTimeCP, Uint4>::operator bool(void) const
1626 {
1627 return m_Value != 0;
1628 }
1629
1630 template <> template <>
1631 inline
operator bool(void) const1632 CValueConvert<SSafeCP, Int4>::operator bool(void) const
1633 {
1634 return m_Value != 0;
1635 }
1636
1637 template <> template <>
1638 inline
operator bool(void) const1639 CValueConvert<SRunTimeCP, Int4>::operator bool(void) const
1640 {
1641 return m_Value != 0;
1642 }
1643
1644 #if NCBI_INT8_IS_LONG
1645 template <> template <>
1646 inline
operator bool(void) const1647 CValueConvert<SSafeCP, unsigned long long>::operator bool(void) const
1648 {
1649 return m_Value != 0;
1650 }
1651
1652 template <> template <>
1653 inline
operator bool(void) const1654 CValueConvert<SRunTimeCP, unsigned long long>::operator bool(void) const
1655 {
1656 return m_Value != 0;
1657 }
1658
1659 template <> template <>
1660 inline
operator bool(void) const1661 CValueConvert<SSafeCP, long long>::operator bool(void) const
1662 {
1663 return m_Value != 0;
1664 }
1665
1666 template <> template <>
1667 inline
operator bool(void) const1668 CValueConvert<SRunTimeCP, long long>::operator bool(void) const
1669 {
1670 return m_Value != 0;
1671 }
1672 #else
1673 template <> template <>
1674 inline
operator bool(void) const1675 CValueConvert<SSafeCP, Uint8>::operator bool(void) const
1676 {
1677 return m_Value != 0;
1678 }
1679
1680 template <> template <>
1681 inline
operator bool(void) const1682 CValueConvert<SRunTimeCP, Uint8>::operator bool(void) const
1683 {
1684 return m_Value != 0;
1685 }
1686
1687 template <> template <>
1688 inline
operator bool(void) const1689 CValueConvert<SSafeCP, Int8>::operator bool(void) const
1690 {
1691 return m_Value != 0;
1692 }
1693
1694 template <> template <>
1695 inline
operator bool(void) const1696 CValueConvert<SRunTimeCP, Int8>::operator bool(void) const
1697 {
1698 return m_Value != 0;
1699 }
1700 #endif
1701
1702 // CTime has "empty" value semantic.
1703 template <> template <>
1704 inline
operator bool(void) const1705 CValueConvert<SRunTimeCP, CTime>::operator bool(void) const
1706 {
1707 return !m_Value->IsEmpty();
1708 }
1709
1710 #endif
1711
1712 } // namespace value_slice
1713
1714 #if defined(NCBI_COMPILER_WORKSHOP) || \
1715 (defined(NCBI_COMPILER_MSVC) && (_MSC_VER < 1400))
1716 namespace value_slice
1717 {
1718
1719 template <typename CP, typename FROM>
1720 inline
operator !(CValueConvert<CP,FROM> const & value)1721 bool operator !(CValueConvert<CP, FROM> const& value)
1722 {
1723 const bool bool_expr = value;
1724 return !bool_expr;
1725 }
1726
1727 template <
1728 typename CP1,
1729 typename CP2,
1730 typename FROM1,
1731 typename FROM2
1732 >
1733 inline
operator &&(CValueConvert<CP1,FROM1> const & l,CValueConvert<CP2,FROM2> const & r)1734 bool operator &&(CValueConvert<CP1, FROM1> const& l, CValueConvert<CP2, FROM2> const& r)
1735 {
1736 const bool l_expr = l;
1737
1738 if (!l) {
1739 return false;
1740 }
1741
1742 return r;
1743 }
1744
1745 template <
1746 typename CP1,
1747 typename CP2,
1748 typename FROM1,
1749 typename FROM2
1750 >
1751 inline
operator ||(CValueConvert<CP1,FROM1> const & l,CValueConvert<CP2,FROM2> const & r)1752 bool operator ||(CValueConvert<CP1, FROM1> const& l, CValueConvert<CP2, FROM2> const& r)
1753 {
1754 const bool l_expr = l;
1755
1756 if (l) {
1757 return true;
1758 }
1759
1760 return r;
1761 }
1762
1763 template <typename CP, typename FROM>
1764 inline
operator &&(bool l,CValueConvert<CP,FROM> const & r)1765 bool operator &&(bool l, CValueConvert<CP, FROM> const& r)
1766 {
1767 if (!l) {
1768 return false;
1769 }
1770
1771 return r;
1772 }
1773
1774 template <typename CP, typename FROM>
1775 inline
operator &&(CValueConvert<CP,FROM> const & l,bool r)1776 bool operator &&(CValueConvert<CP, FROM> const& l, bool r)
1777 {
1778 const bool l_expr = l;
1779 return l_expr && r;
1780 }
1781
1782 template <typename CP, typename FROM>
1783 inline
operator ||(bool l,CValueConvert<CP,FROM> const & r)1784 bool operator ||(bool l, CValueConvert<CP, FROM> const& r)
1785 {
1786 if (l) {
1787 return true;
1788 }
1789
1790 return r;
1791 }
1792
1793 template <typename CP, typename FROM>
1794 inline
operator ||(CValueConvert<CP,FROM> const & l,bool r)1795 bool operator ||(CValueConvert<CP, FROM> const& l, bool r)
1796 {
1797 const bool l_expr = l;
1798 return l_expr || r;
1799 }
1800
1801 }
1802
1803 #endif
1804
1805 ////////////////////////////////////////////////////////////////////////////////
1806 template <typename CP, typename FROM>
1807 inline
operator +(const string & s,const value_slice::CValueConvert<CP,FROM> & value)1808 string operator+(const string& s, const value_slice::CValueConvert<CP, FROM>& value)
1809 {
1810 string str_value(s);
1811
1812 str_value += value.operator string();
1813 return str_value;
1814 }
1815
1816 template <typename CP, typename FROM>
1817 inline
operator +(const value_slice::CValueConvert<CP,FROM> & value,const string & s)1818 string operator+(const value_slice::CValueConvert<CP, FROM>& value, const string& s)
1819 {
1820 string str_value = value.operator string();
1821
1822 str_value += s;
1823 return str_value;
1824 }
1825
1826 template <typename CP, typename FROM>
1827 inline
operator +(const char * s,const value_slice::CValueConvert<CP,FROM> & value)1828 string operator+(const char* s, const value_slice::CValueConvert<CP, FROM>& value)
1829 {
1830 string str_value;
1831
1832 if (s) {
1833 str_value += s;
1834 }
1835
1836 str_value += value.operator string();
1837
1838 return str_value;
1839 }
1840
1841 template <typename CP, typename FROM>
1842 inline
operator +(const value_slice::CValueConvert<CP,FROM> & value,const char * s)1843 string operator+(const value_slice::CValueConvert<CP, FROM>& value, const char* s)
1844 {
1845 string str_value = value.operator string();
1846
1847 if (s) {
1848 str_value += s;
1849 }
1850
1851 return str_value;
1852 }
1853
1854 template <typename CP, typename FROM>
1855 inline
operator +=(string & s,const value_slice::CValueConvert<CP,FROM> & value)1856 string& operator+=(string& s, const value_slice::CValueConvert<CP, FROM>& value)
1857 {
1858 s += value.operator string();
1859 return s;
1860 }
1861
1862 ////////////////////////////////////////////////////////////////////////////////
1863 // A limited case ...
1864 template <typename FROM>
1865 inline
1866 const value_slice::CValueConvert<value_slice::SRunTimeCP, FROM>
Convert(const FROM & value)1867 Convert(const FROM& value)
1868 {
1869 return value_slice::CValueConvert<value_slice::SRunTimeCP, FROM>(value);
1870 }
1871
1872 #if SIZEOF_LONG == 4
1873 inline
1874 const value_slice::CValueConvert<value_slice::SRunTimeCP, Int4>
Convert(long value)1875 Convert(long value)
1876 {
1877 return value_slice::CValueConvert<value_slice::SRunTimeCP, Int4>(value);
1878 }
1879
1880 inline
1881 const value_slice::CValueConvert<value_slice::SRunTimeCP, Uint4>
Convert(unsigned long value)1882 Convert(unsigned long value)
1883 {
1884 return value_slice::CValueConvert<value_slice::SRunTimeCP, Uint4>(value);
1885 }
1886 #endif
1887
1888 template <typename FROM>
1889 inline
1890 const value_slice::CValueConvert<value_slice::SRunTimeCP, FROM>
Convert(FROM & value)1891 Convert(FROM& value)
1892 {
1893 return value_slice::CValueConvert<value_slice::SRunTimeCP, FROM>(value);
1894 }
1895
1896 ////////////////////////////////////////////////////////////////////////////////
1897 // Safe (compile-time) conversion ...
1898 template <typename FROM>
1899 inline
1900 const value_slice::CValueConvert<value_slice::SSafeCP, FROM>
ConvertSafe(const FROM & value)1901 ConvertSafe(const FROM& value)
1902 {
1903 return value_slice::CValueConvert<value_slice::SSafeCP, FROM>(value);
1904 }
1905
1906 #if SIZEOF_LONG == 4
1907 inline
1908 const value_slice::CValueConvert<value_slice::SSafeCP, Int4>
ConvertSafe(long value)1909 ConvertSafe(long value)
1910 {
1911 return value_slice::CValueConvert<value_slice::SSafeCP, Int4>(value);
1912 }
1913
1914 inline
1915 const value_slice::CValueConvert<value_slice::SSafeCP, Uint4>
ConvertSafe(unsigned long value)1916 ConvertSafe(unsigned long value)
1917 {
1918 return value_slice::CValueConvert<value_slice::SSafeCP, Uint4>(value);
1919 }
1920 #endif
1921
1922 template <typename FROM>
1923 inline
1924 const value_slice::CValueConvert<value_slice::SSafeCP, FROM>
ConvertSafe(FROM & value)1925 ConvertSafe(FROM& value)
1926 {
1927 return value_slice::CValueConvert<value_slice::SSafeCP, FROM>(value);
1928 }
1929
1930 END_NCBI_SCOPE
1931
1932
1933 #endif // UTIL___VALUE_CONVERT__HPP
1934