Mercurial > hg > orthanc

comparison OrthancFramework/Sources/SerializationToolbox.cpp @ 4775:add0337b928a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
refactoring parsing of numbers
author Sebastien Jodogne <s.jodogne@gmail.com>
date Mon, 30 Aug 2021 10:24:36 +0200
parents f4dbdb2dcba6
children 7053502fbf97
comparison
equal deleted inserted replaced
4771:9f207131c7f4 4775:add0337b928a
22 22
23 #include "PrecompiledHeaders.h" 23 #include "PrecompiledHeaders.h"
24 #include "SerializationToolbox.h" 24 #include "SerializationToolbox.h"
25 25
26 #include "OrthancException.h" 26 #include "OrthancException.h"
27 #include "Toolbox.h"
27 28
28 #if ORTHANC_ENABLE_DCMTK == 1 29 #if ORTHANC_ENABLE_DCMTK == 1
29 # include "DicomParsing/FromDcmtkBridge.h" 30 # include "DicomParsing/FromDcmtkBridge.h"
30 #endif 31 #endif
32
33 #include <boost/lexical_cast.hpp>
34
31 35
32 namespace Orthanc 36 namespace Orthanc
33 { 37 {
34 static bool ParseTagInternal(DicomTag& tag, 38 static bool ParseTagInternal(DicomTag& tag,
35 const char* name) 39 const char* name)
443 it = values.begin(); it != values.end(); ++it) 447 it = values.begin(); it != values.end(); ++it)
444 { 448 {
445 value[it->first.Format()] = it->second; 449 value[it->first.Format()] = it->second;
446 } 450 }
447 } 451 }
452
453
454 template <typename T,
455 bool allowSigned>
456 static bool ParseValue(T& target,
457 const std::string& source)
458 {
459 try
460 {
461 std::string value = Toolbox::StripSpaces(source);
462 if (value.empty())
463 {
464 return false;
465 }
466 else if (!allowSigned &&
467 value[0] == '-')
468 {
469 return false;
470 }
471 else
472 {
473 target = boost::lexical_cast<T>(value);
474 return true;
475 }
476 }
477 catch (boost::bad_lexical_cast&)
478 {
479 return false;
480 }
481 }
482
483
484 bool SerializationToolbox::ParseInteger32(int32_t& target,
485 const std::string& source)
486 {
487 int64_t tmp;
488 if (ParseValue<int64_t, true>(tmp, source))
489 {
490 target = static_cast<int32_t>(tmp);
491 return (tmp == static_cast<int64_t>(target)); // Check no overflow occurs
492 }
493 else
494 {
495 return false;
496 }
497 }
498
499
500 bool SerializationToolbox::ParseInteger64(int64_t& target,
501 const std::string& source)
502 {
503 return ParseValue<int64_t, true>(target, source);
504 }
505
506
507 bool SerializationToolbox::ParseUnsignedInteger32(uint32_t& target,
508 const std::string& source)
509 {
510 uint64_t tmp;
511 if (ParseValue<uint64_t, false>(tmp, source))
512 {
513 target = static_cast<uint32_t>(tmp);
514 return (tmp == static_cast<uint64_t>(target)); // Check no overflow occurs
515 }
516 else
517 {
518 return false;
519 }
520 }
521
522
523 bool SerializationToolbox::ParseUnsignedInteger64(uint64_t& target,
524 const std::string& source)
525 {
526 return ParseValue<uint64_t, false>(target, source);
527 }
528
529
530 bool SerializationToolbox::ParseFloat(float& target,
531 const std::string& source)
532 {
533 return ParseValue<float, true>(target, source);
534 }
535
536
537 bool SerializationToolbox::ParseDouble(double& target,
538 const std::string& source)
539 {
540 return ParseValue<double, true>(target, source);
541 }
542
543
544 static bool GetFirstItem(std::string& target,
545 const std::string& source)
546 {
547 std::vector<std::string> tokens;
548 Toolbox::TokenizeString(tokens, source, '\\');
549
550 if (tokens.empty())
551 {
552 return false;
553 }
554 else
555 {
556 target = tokens[0];
557 return true;
558 }
559 }
560
561
562 bool SerializationToolbox::ParseFirstInteger32(int32_t& target,
563 const std::string& source)
564 {
565 std::string first;
566 if (GetFirstItem(first, source))
567 {
568 return ParseInteger32(target, first);
569 }
570 else
571 {
572 return false;
573 }
574 }
575
576
577 bool SerializationToolbox::ParseFirstInteger64(int64_t& target,
578 const std::string& source)
579 {
580 std::string first;
581 if (GetFirstItem(first, source))
582 {
583 return ParseInteger64(target, first);
584 }
585 else
586 {
587 return false;
588 }
589 }
590
591
592 bool SerializationToolbox::ParseFirstUnsignedInteger32(uint32_t& target,
593 const std::string& source)
594 {
595 std::string first;
596 if (GetFirstItem(first, source))
597 {
598 return ParseUnsignedInteger32(target, first);
599 }
600 else
601 {
602 return false;
603 }
604 }
605
606
607 bool SerializationToolbox::ParseFirstUnsignedInteger64(uint64_t& target,
608 const std::string& source)
609 {
610 std::string first;
611 if (GetFirstItem(first, source))
612 {
613 return ParseUnsignedInteger64(target, first);
614 }
615 else
616 {
617 return false;
618 }
619 }
620
621
622 bool SerializationToolbox::ParseFirstFloat(float& target,
623 const std::string& source)
624 {
625 std::string first;
626 if (GetFirstItem(first, source))
627 {
628 return ParseFloat(target, first);
629 }
630 else
631 {
632 return false;
633 }
634 }
635
636
637 bool SerializationToolbox::ParseFirstDouble(double& target,
638 const std::string& source)
639 {
640 std::string first;
641 if (GetFirstItem(first, source))
642 {
643 return ParseDouble(target, first);
644 }
645 else
646 {
647 return false;
648 }
649 }
448 } 650 }