Abseil Common Libraries (C++) (grcp 依赖)
https://abseil.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
7.9 KiB
245 lines
7.9 KiB
// Copyright 2017 The Abseil Authors. |
|
// |
|
// Licensed under the Apache License, Version 2.0 (the "License"); |
|
// you may not use this file except in compliance with the License. |
|
// You may obtain a copy of the License at |
|
// |
|
// https://www.apache.org/licenses/LICENSE-2.0 |
|
// |
|
// Unless required by applicable law or agreed to in writing, software |
|
// distributed under the License is distributed on an "AS IS" BASIS, |
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
// See the License for the specific language governing permissions and |
|
// limitations under the License. |
|
|
|
#ifndef ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_ |
|
#define ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_ |
|
|
|
#include <cmath> |
|
#include <iostream> |
|
#include <limits> |
|
#include <type_traits> |
|
|
|
#include "absl/meta/type_traits.h" |
|
#include "absl/numeric/int128.h" |
|
|
|
namespace absl { |
|
ABSL_NAMESPACE_BEGIN |
|
namespace random_internal { |
|
|
|
// The null_state_saver does nothing. |
|
template <typename T> |
|
class null_state_saver { |
|
public: |
|
using stream_type = T; |
|
using flags_type = std::ios_base::fmtflags; |
|
|
|
null_state_saver(T&, flags_type) {} |
|
~null_state_saver() {} |
|
}; |
|
|
|
// ostream_state_saver is a RAII object to save and restore the common |
|
// basic_ostream flags used when implementing `operator <<()` on any of |
|
// the absl random distributions. |
|
template <typename OStream> |
|
class ostream_state_saver { |
|
public: |
|
using ostream_type = OStream; |
|
using flags_type = std::ios_base::fmtflags; |
|
using fill_type = typename ostream_type::char_type; |
|
using precision_type = std::streamsize; |
|
|
|
ostream_state_saver(ostream_type& os, // NOLINT(runtime/references) |
|
flags_type flags, fill_type fill) |
|
: os_(os), |
|
flags_(os.flags(flags)), |
|
fill_(os.fill(fill)), |
|
precision_(os.precision()) { |
|
// Save state in initialized variables. |
|
} |
|
|
|
~ostream_state_saver() { |
|
// Restore saved state. |
|
os_.precision(precision_); |
|
os_.fill(fill_); |
|
os_.flags(flags_); |
|
} |
|
|
|
private: |
|
ostream_type& os_; |
|
const flags_type flags_; |
|
const fill_type fill_; |
|
const precision_type precision_; |
|
}; |
|
|
|
#if defined(__NDK_MAJOR__) && __NDK_MAJOR__ < 16 |
|
#define ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT 1 |
|
#else |
|
#define ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT 0 |
|
#endif |
|
|
|
template <typename CharT, typename Traits> |
|
ostream_state_saver<std::basic_ostream<CharT, Traits>> make_ostream_state_saver( |
|
std::basic_ostream<CharT, Traits>& os, // NOLINT(runtime/references) |
|
std::ios_base::fmtflags flags = std::ios_base::dec | std::ios_base::left | |
|
#if ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT |
|
std::ios_base::fixed | |
|
#endif |
|
std::ios_base::scientific) { |
|
using result_type = ostream_state_saver<std::basic_ostream<CharT, Traits>>; |
|
return result_type(os, flags, os.widen(' ')); |
|
} |
|
|
|
template <typename T> |
|
typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value, |
|
null_state_saver<T>> |
|
make_ostream_state_saver(T& is, // NOLINT(runtime/references) |
|
std::ios_base::fmtflags flags = std::ios_base::dec) { |
|
std::cerr << "null_state_saver"; |
|
using result_type = null_state_saver<T>; |
|
return result_type(is, flags); |
|
} |
|
|
|
// stream_precision_helper<type>::kPrecision returns the base 10 precision |
|
// required to stream and reconstruct a real type exact binary value through |
|
// a binary->decimal->binary transition. |
|
template <typename T> |
|
struct stream_precision_helper { |
|
// max_digits10 may be 0 on MSVC; if so, use digits10 + 3. |
|
static constexpr int kPrecision = |
|
(std::numeric_limits<T>::max_digits10 > std::numeric_limits<T>::digits10) |
|
? std::numeric_limits<T>::max_digits10 |
|
: (std::numeric_limits<T>::digits10 + 3); |
|
}; |
|
|
|
template <> |
|
struct stream_precision_helper<float> { |
|
static constexpr int kPrecision = 9; |
|
}; |
|
template <> |
|
struct stream_precision_helper<double> { |
|
static constexpr int kPrecision = 17; |
|
}; |
|
template <> |
|
struct stream_precision_helper<long double> { |
|
static constexpr int kPrecision = 36; // assuming fp128 |
|
}; |
|
|
|
// istream_state_saver is a RAII object to save and restore the common |
|
// std::basic_istream<> flags used when implementing `operator >>()` on any of |
|
// the absl random distributions. |
|
template <typename IStream> |
|
class istream_state_saver { |
|
public: |
|
using istream_type = IStream; |
|
using flags_type = std::ios_base::fmtflags; |
|
|
|
istream_state_saver(istream_type& is, // NOLINT(runtime/references) |
|
flags_type flags) |
|
: is_(is), flags_(is.flags(flags)) {} |
|
|
|
~istream_state_saver() { is_.flags(flags_); } |
|
|
|
private: |
|
istream_type& is_; |
|
flags_type flags_; |
|
}; |
|
|
|
template <typename CharT, typename Traits> |
|
istream_state_saver<std::basic_istream<CharT, Traits>> make_istream_state_saver( |
|
std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references) |
|
std::ios_base::fmtflags flags = std::ios_base::dec | |
|
std::ios_base::scientific | |
|
std::ios_base::skipws) { |
|
using result_type = istream_state_saver<std::basic_istream<CharT, Traits>>; |
|
return result_type(is, flags); |
|
} |
|
|
|
template <typename T> |
|
typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value, |
|
null_state_saver<T>> |
|
make_istream_state_saver(T& is, // NOLINT(runtime/references) |
|
std::ios_base::fmtflags flags = std::ios_base::dec) { |
|
using result_type = null_state_saver<T>; |
|
return result_type(is, flags); |
|
} |
|
|
|
// stream_format_type<T> is a helper struct to convert types which |
|
// basic_iostream cannot output as decimal numbers into types which |
|
// basic_iostream can output as decimal numbers. Specifically: |
|
// * signed/unsigned char-width types are converted to int. |
|
// * TODO(lar): __int128 => uint128, except there is no operator << yet. |
|
// |
|
template <typename T> |
|
struct stream_format_type |
|
: public std::conditional<(sizeof(T) == sizeof(char)), int, T> {}; |
|
|
|
// stream_u128_helper allows us to write out either absl::uint128 or |
|
// __uint128_t types in the same way, which enables their use as internal |
|
// state of PRNG engines. |
|
template <typename T> |
|
struct stream_u128_helper; |
|
|
|
template <> |
|
struct stream_u128_helper<absl::uint128> { |
|
template <typename IStream> |
|
inline absl::uint128 read(IStream& in) { |
|
uint64_t h = 0; |
|
uint64_t l = 0; |
|
in >> h >> l; |
|
return absl::MakeUint128(h, l); |
|
} |
|
|
|
template <typename OStream> |
|
inline void write(absl::uint128 val, OStream& out) { |
|
uint64_t h = Uint128High64(val); |
|
uint64_t l = Uint128Low64(val); |
|
out << h << out.fill() << l; |
|
} |
|
}; |
|
|
|
#ifdef ABSL_HAVE_INTRINSIC_INT128 |
|
template <> |
|
struct stream_u128_helper<__uint128_t> { |
|
template <typename IStream> |
|
inline __uint128_t read(IStream& in) { |
|
uint64_t h = 0; |
|
uint64_t l = 0; |
|
in >> h >> l; |
|
return (static_cast<__uint128_t>(h) << 64) | l; |
|
} |
|
|
|
template <typename OStream> |
|
inline void write(__uint128_t val, OStream& out) { |
|
uint64_t h = static_cast<uint64_t>(val >> 64u); |
|
uint64_t l = static_cast<uint64_t>(val); |
|
out << h << out.fill() << l; |
|
} |
|
}; |
|
#endif |
|
|
|
template <typename FloatType, typename IStream> |
|
inline FloatType read_floating_point(IStream& is) { |
|
static_assert(std::is_floating_point<FloatType>::value, ""); |
|
FloatType dest; |
|
is >> dest; |
|
// Parsing a double value may report a subnormal value as an error |
|
// despite being able to represent it. |
|
// See https://stackoverflow.com/q/52410931/3286653 |
|
// It may also report an underflow when parsing DOUBLE_MIN as an |
|
// ERANGE error, as the parsed value may be smaller than DOUBLE_MIN |
|
// and rounded up. |
|
// See: https://stackoverflow.com/q/42005462 |
|
if (is.fail() && |
|
(std::fabs(dest) == (std::numeric_limits<FloatType>::min)() || |
|
std::fpclassify(dest) == FP_SUBNORMAL)) { |
|
is.clear(is.rdstate() & (~std::ios_base::failbit)); |
|
} |
|
return dest; |
|
} |
|
|
|
} // namespace random_internal |
|
ABSL_NAMESPACE_END |
|
} // namespace absl |
|
|
|
#endif // ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_
|
|
|