legacy-libs/grpc/deps/grpc/third_party/abseil-cpp/absl/strings/internal/charconv_parse.h

   1 // Copyright 2018 The Abseil Authors.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //      https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
  16 #define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
  17
  18 #include <cstdint>
  19
  20 #include "absl/strings/charconv.h"
  21
  22 namespace absl {
  23 namespace strings_internal {
  24
  25 // Enum indicating whether a parsed float is a number or special value.
  26 enum class FloatType { kNumber, kInfinity, kNan };
  27
  28 // The decomposed parts of a parsed `float` or `double`.
  29 struct ParsedFloat {
  30   // Representation of the parsed mantissa, with the decimal point adjusted to
  31   // make it an integer.
  32   //
  33   // During decimal scanning, this contains 19 significant digits worth of
  34   // mantissa value.  If digits beyond this point are found, they
  35   // are truncated, and if any of these dropped digits are nonzero, then
  36   // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
  37   // subrange_end).
  38   //
  39   // During hexadecimal scanning, this contains 15 significant hex digits worth
  40   // of mantissa value.  Digits beyond this point are sticky -- they are
  41   // truncated, but if any dropped digits are nonzero, the low bit of mantissa
  42   // will be set.  (This allows for precise rounding, and avoids the need
  43   // to store the full mantissa in [subrange_begin, subrange_end).)
  44   uint64_t mantissa = 0;
  45
  46   // Floating point expontent.  This reflects any decimal point adjustments and
  47   // any truncated digits from the mantissa.  The absolute value of the parsed
  48   // number is represented by mantissa * (base ** exponent), where base==10 for
  49   // decimal floats, and base==2 for hexadecimal floats.
  50   int exponent = 0;
  51
  52   // The literal exponent value scanned from the input, or 0 if none was
  53   // present.  This does not reflect any adjustments applied to mantissa.
  54   int literal_exponent = 0;
  55
  56   // The type of number scanned.
  57   FloatType type = FloatType::kNumber;
  58
  59   // When non-null, [subrange_begin, subrange_end) marks a range of characters
  60   // that require further processing.  The meaning is dependent on float type.
  61   // If type == kNumber and this is set, this is a "wide input": the input
  62   // mantissa contained more than 19 digits.  The range contains the full
  63   // mantissa.  It plus `literal_exponent` need to be examined to find the best
  64   // floating point match.
  65   // If type == kNan and this is set, the range marks the contents of a
  66   // matched parenthesized character region after the NaN.
  67   const char* subrange_begin = nullptr;
  68   const char* subrange_end = nullptr;
  69
  70   // One-past-the-end of the successfully parsed region, or nullptr if no
  71   // matching pattern was found.
  72   const char* end = nullptr;
  73 };
  74
  75 // Read the floating point number in the provided range, and populate
  76 // ParsedFloat accordingly.
  77 //
  78 // format_flags is a bitmask value specifying what patterns this API will match.
  79 // `scientific` and `fixed`  are honored per std::from_chars rules
  80 // ([utility.from.chars], C++17): if exactly one of these bits is set, then an
  81 // exponent is required, or dislallowed, respectively.
  82 //
  83 // Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
  84 // *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
  85 template <int base>
  86 ParsedFloat ParseFloat(const char* begin, const char* end,
  87                        absl::chars_format format_flags);
  88
  89 extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
  90                                            absl::chars_format format_flags);
  91 extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
  92                                            absl::chars_format format_flags);
  93
  94 }  // namespace strings_internal
  95 }  // namespace absl
  96 #endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_