charconv_parse.h
Go to the documentation of this file.
00001 // Copyright 2018 The Abseil Authors.
00002 //
00003 // Licensed under the Apache License, Version 2.0 (the "License");
00004 // you may not use this file except in compliance with the License.
00005 // You may obtain a copy of the License at
00006 //
00007 //      https://www.apache.org/licenses/LICENSE-2.0
00008 //
00009 // Unless required by applicable law or agreed to in writing, software
00010 // distributed under the License is distributed on an "AS IS" BASIS,
00011 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00012 // See the License for the specific language governing permissions and
00013 // limitations under the License.
00014 
00015 #ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
00016 #define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
00017 
00018 #include <cstdint>
00019 
00020 #include "absl/strings/charconv.h"
00021 
00022 namespace absl {
00023 namespace strings_internal {
00024 
00025 // Enum indicating whether a parsed float is a number or special value.
00026 enum class FloatType { kNumber, kInfinity, kNan };
00027 
00028 // The decomposed parts of a parsed `float` or `double`.
00029 struct ParsedFloat {
00030   // Representation of the parsed mantissa, with the decimal point adjusted to
00031   // make it an integer.
00032   //
00033   // During decimal scanning, this contains 19 significant digits worth of
00034   // mantissa value.  If digits beyond this point are found, they
00035   // are truncated, and if any of these dropped digits are nonzero, then
00036   // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
00037   // subrange_end).
00038   //
00039   // During hexadecimal scanning, this contains 15 significant hex digits worth
00040   // of mantissa value.  Digits beyond this point are sticky -- they are
00041   // truncated, but if any dropped digits are nonzero, the low bit of mantissa
00042   // will be set.  (This allows for precise rounding, and avoids the need
00043   // to store the full mantissa in [subrange_begin, subrange_end).)
00044   uint64_t mantissa = 0;
00045 
00046   // Floating point expontent.  This reflects any decimal point adjustments and
00047   // any truncated digits from the mantissa.  The absolute value of the parsed
00048   // number is represented by mantissa * (base ** exponent), where base==10 for
00049   // decimal floats, and base==2 for hexadecimal floats.
00050   int exponent = 0;
00051 
00052   // The literal exponent value scanned from the input, or 0 if none was
00053   // present.  This does not reflect any adjustments applied to mantissa.
00054   int literal_exponent = 0;
00055 
00056   // The type of number scanned.
00057   FloatType type = FloatType::kNumber;
00058 
00059   // When non-null, [subrange_begin, subrange_end) marks a range of characters
00060   // that require further processing.  The meaning is dependent on float type.
00061   // If type == kNumber and this is set, this is a "wide input": the input
00062   // mantissa contained more than 19 digits.  The range contains the full
00063   // mantissa.  It plus `literal_exponent` need to be examined to find the best
00064   // floating point match.
00065   // If type == kNan and this is set, the range marks the contents of a
00066   // matched parenthesized character region after the NaN.
00067   const char* subrange_begin = nullptr;
00068   const char* subrange_end = nullptr;
00069 
00070   // One-past-the-end of the successfully parsed region, or nullptr if no
00071   // matching pattern was found.
00072   const char* end = nullptr;
00073 };
00074 
00075 // Read the floating point number in the provided range, and populate
00076 // ParsedFloat accordingly.
00077 //
00078 // format_flags is a bitmask value specifying what patterns this API will match.
00079 // `scientific` and `fixed`  are honored per std::from_chars rules
00080 // ([utility.from.chars], C++17): if exactly one of these bits is set, then an
00081 // exponent is required, or dislallowed, respectively.
00082 //
00083 // Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
00084 // *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
00085 template <int base>
00086 ParsedFloat ParseFloat(const char* begin, const char* end,
00087                        absl::chars_format format_flags);
00088 
00089 extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
00090                                            absl::chars_format format_flags);
00091 extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
00092                                            absl::chars_format format_flags);
00093 
00094 }  // namespace strings_internal
00095 }  // namespace absl
00096 #endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_


abseil_cpp
Author(s):
autogenerated on Wed Jun 19 2019 19:42:14