EIC code displayed by LXR master/​include/​root/​ROOT/​StringConv.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:10:50

 // @(#)root/base
 // Author: Philippe Canal 12/2015
 
 /*************************************************************************
  * Copyright (C) 1995-2015, Rene Brun and Fons Rademakers.               *
  * All rights reserved.                                                  *
  *                                                                       *
  * For the licensing terms see $ROOTSYS/LICENSE.                         *
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
 #ifndef ROOT_StringConv
 #define ROOT_StringConv
 
 
 #include <string_view>
 #include "Rtypes.h"
 #include "RConfigure.h"
 #include <cmath>
 
 namespace ROOT {
 
    // Adapted from http://stackoverflow.com/questions/3758606/
    // how-to-convert-byte-size-into-human-readable-format-in-java
    // and http://agentzlerich.blogspot.com/2011/01/converting-to-and-from-human-readable.html
    // However those sources use the 'conventional' 'legacy' nomenclature,
    // rather than the official Standard Units.  See
    // http://physics.nist.gov/cuu/Units/binary.html
    // and http://www.dr-lex.be/info-stuff/bytecalc.html for example.
 
 ///////////////////////////////////////////////////////////////////////////////
 /// Return the size expressed in 'human readable' format.
 /// \param bytes the size in bytes to be converted
 /// \param si whether to use the SI units or not.
 /// \param coeff return the size expressed in the new unit.
 /// \param units return a pointer to the string representation of the new unit
 template <typename value_type>
 void ToHumanReadableSize(value_type bytes,
                          Bool_t si,
                          Double_t *coeff,
                          const char **units)
 {
    // Static lookup table of byte-based SI units
    static const char *const suffix[][2] =
    { { "B",  "B"   },
      { "KB", "KiB" },
      { "MB", "MiB" },
      { "GB", "GiB" },
      { "TB", "TiB" },
      { "EB", "EiB" },
      { "ZB", "ZiB" },
      { "YB", "YiB" } };
    value_type unit = si ? 1000 : 1024;
    int exp = 0;
    if (bytes == unit) {
       // On some 32bit platforms, the result of
       //    (int) (std::log(bytes) / std::log(unit)
       // in the case of bytes==unit ends up surprisingly to be zero
       // rather than one, so 'hard code' the result
       exp = 1;
    } else if (bytes > 0) {
       exp = std::min( (int) (std::log(bytes) / std::log(unit)),
                      (int) (sizeof(suffix) / sizeof(suffix[0]) - 1));
    }
    *coeff = bytes / std::pow(unit, exp);
    *units  = suffix[exp][!si];
 }
 
 enum class EFromHumanReadableSize {
    kSuccess,
    kParseFail,
    kOverflow
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 /// Convert strings like the following into byte counts
 ///    5MB, 5 MB, 5M, 3.7GB, 123b, 456kB, 3.7GiB, 5MiB
 /// with some amount of forgiveness baked into the parsing.
 /// For this routine we use the official SI unit where the [i] is reserved
 /// for the 'legacy' power of two units.  1KB = 1000 bytes, 1KiB = 1024 bytes.
 /// \param str the string to be parsed
 /// \param value will be updated with the result if and only if the parse is successful and does not overflow for the type of value.
 /// \return return a EFromHumanReadableSize enum value indicating the success or failure of the parse.
 ///
 template <typename T>
 EFromHumanReadableSize FromHumanReadableSize(std::string_view str, T &value)
 {
    try {
       size_t cur, size = str.size();
       // Parse leading numeric factor
       const double coeff = stod(std::string(str.data(), str.size()), &cur);
 
       // Skip any intermediate white space
       while (cur<size && isspace(str[cur])) ++cur;
 
       // Read off first character which should be an SI prefix
       int exp = 0, unit = 1000;
 
       auto result = [coeff,&exp,&unit,&value]() {
          double v = exp ? coeff * std::pow(unit, exp / 3) : coeff;
          if (v < (double) std::numeric_limits<T>::max()) {
             value = (T)v;
             return EFromHumanReadableSize::kSuccess;
          } else {
             return EFromHumanReadableSize::kOverflow;
          }
       };
       if (cur==size) return result();
 
       switch (toupper(str[cur])) {
          case 'B':  exp =  0; break;
          case 'K':  exp =  3; break;
          case 'M':  exp =  6; break;
          case 'G':  exp =  9; break;
          case 'T':  exp = 12; break;
          case 'E':  exp = 15; break;
          case 'Z':  exp = 18; break;
          case 'Y':  exp = 21; break;
 
          default:   return EFromHumanReadableSize::kParseFail;
       }
       ++cur;
 
       // If an 'i' or 'I' is present use non-SI factor-of-1024 units
       if (cur<size && toupper(str[cur]) == 'I') {
          ++cur;
          unit = 1024;
       }
 
       if (cur==size) return result();
 
       // Next character must be one of B/empty/whitespace
       switch (toupper(str[cur])) {
          case 'B':
          case ' ':
          case '\t': ++cur;  break;
 
          case '\0': return result();
 
          default:   return EFromHumanReadableSize::kParseFail;
       }
 
       // Skip any remaining white space
       // while (cur<size && isspace(str[cur])) ++cur;
 
       // Do not:
       // Parse error on anything but a null terminator
       // if (cur<size) return -1;
 
       return result();
    } catch (...) {
       return EFromHumanReadableSize::kParseFail;
    }
 
 }
 
 } // namespace ROOT.
 
 #endif // ROOT_StringConv

This page was automatically generated by the 2.3.7 LXR engine. The LXR team